librbd::api::Mirror<>::mode_set(m_local_io_ctx, RBD_MIRROR_MODE_IMAGE);
- m_deleter = new rbd::mirror::ImageDeleter(m_threads->work_queue,
- m_threads->timer,
- &m_threads->timer_lock);
+ m_deleter = new rbd::mirror::ImageDeleter<>(m_threads->work_queue,
+ m_threads->timer,
+ &m_threads->timer_lock);
EXPECT_EQ(0, create_image(rbd, m_local_io_ctx, m_image_name, 1 << 20));
ImageCtx *ictx = new ImageCtx(m_image_name, "", "", m_local_io_ctx,
librbd::RBD rbd;
std::string m_local_image_id;
- rbd::mirror::ImageDeleter *m_deleter;
+ rbd::mirror::ImageDeleter<> *m_deleter;
};
int64_t TestImageDeleter::m_local_pool_id;
C_SaferCond ctx;
m_deleter->wait_for_scheduled_deletion(m_local_pool_id, GLOBAL_IMAGE_ID,
&ctx);
- EXPECT_EQ(-rbd::mirror::ImageDeleter::EISPRM, ctx.wait());
+ EXPECT_EQ(-rbd::mirror::ImageDeleter<>::EISPRM, ctx.wait());
ASSERT_EQ(0u, m_deleter->get_delete_queue_items().size());
ASSERT_EQ(0u, m_deleter->get_failed_queue_items().size());
m_threads = new rbd::mirror::Threads<>(reinterpret_cast<CephContext*>(
m_local_ioctx.cct()));
- m_image_deleter.reset(new rbd::mirror::ImageDeleter(m_threads->work_queue,
- m_threads->timer,
- &m_threads->timer_lock));
+ m_image_deleter.reset(new rbd::mirror::ImageDeleter<>(
+ m_threads->work_queue, m_threads->timer, &m_threads->timer_lock));
m_instance_watcher = rbd::mirror::InstanceWatcher<>::create(
m_local_ioctx, m_threads->work_queue, nullptr);
m_instance_watcher->handle_acquire_leader();
template <typename ImageReplayerT = rbd::mirror::ImageReplayer<> >
void create_replayer() {
m_replayer = new ImageReplayerT(
- m_threads, m_image_deleter, m_instance_watcher,
+ m_threads, m_image_deleter.get(), m_instance_watcher,
rbd::mirror::RadosRef(new librados::Rados(m_local_ioctx)),
m_local_mirror_uuid, m_local_ioctx.get_id(), "global image id");
m_replayer->add_remote_image(m_remote_mirror_uuid, m_remote_image_id,
static int _image_number;
rbd::mirror::Threads<> *m_threads = nullptr;
- std::shared_ptr<rbd::mirror::ImageDeleter> m_image_deleter;
+ std::unique_ptr<rbd::mirror::ImageDeleter<>> m_image_deleter;
std::shared_ptr<librados::Rados> m_local_cluster;
librados::Rados m_remote_cluster;
rbd::mirror::InstanceWatcher<> *m_instance_watcher;
#include "cls/journal/cls_journal_types.h"
#include "librbd/journal/Replay.h"
#include "librbd/journal/Types.h"
+#include "tools/rbd_mirror/ImageDeleter.h"
#include "tools/rbd_mirror/ImageReplayer.h"
#include "tools/rbd_mirror/InstanceWatcher.h"
#include "tools/rbd_mirror/image_replayer/BootstrapRequest.h"
namespace rbd {
namespace mirror {
+template <>
+struct ImageDeleter<librbd::MockTestImageCtx> {
+ MOCK_METHOD3(schedule_image_delete, void(RadosRef, int64_t,
+ const std::string&));
+};
+
template<>
class InstanceWatcher<librbd::MockTestImageCtx> {
};
class TestMockImageReplayer : public TestMockFixture {
public:
+ typedef ImageDeleter<librbd::MockTestImageCtx> MockImageDeleter;
typedef BootstrapRequest<librbd::MockTestImageCtx> MockBootstrapRequest;
typedef CloseImageRequest<librbd::MockTestImageCtx> MockCloseImageRequest;
typedef EventPreprocessor<librbd::MockTestImageCtx> MockEventPreprocessor;
librbd::RBD rbd;
ASSERT_EQ(0, create_image(rbd, m_remote_io_ctx, m_image_name, m_image_size));
ASSERT_EQ(0, open_image(m_remote_io_ctx, m_image_name, &m_remote_image_ctx));
-
- m_image_deleter.reset(new rbd::mirror::ImageDeleter(m_threads->work_queue,
- m_threads->timer,
- &m_threads->timer_lock));
- m_image_replayer = new MockImageReplayer(
- m_threads, m_image_deleter, &m_instance_watcher,
- rbd::mirror::RadosRef(new librados::Rados(m_local_io_ctx)),
- "local_mirror_uuid", m_local_io_ctx.get_id(), "global image id");
- m_image_replayer->add_remote_image(
- "remote_mirror_uuid", m_remote_image_ctx->id, m_remote_io_ctx);
}
void TearDown() override {
WithArg<2>(CompleteContext(on_commit_r))));
}
+ void create_image_replayer(MockImageDeleter &mock_image_deleter) {
+ m_image_replayer = new MockImageReplayer(
+ m_threads, &mock_image_deleter, &m_instance_watcher,
+ rbd::mirror::RadosRef(new librados::Rados(m_local_io_ctx)),
+ "local_mirror_uuid", m_local_io_ctx.get_id(), "global image id");
+ m_image_replayer->add_remote_image(
+ "remote_mirror_uuid", m_remote_image_ctx->id, m_remote_io_ctx);
+ }
+
librbd::ImageCtx *m_remote_image_ctx;
librbd::ImageCtx *m_local_image_ctx = nullptr;
- std::shared_ptr<rbd::mirror::ImageDeleter> m_image_deleter;
MockInstanceWatcher m_instance_watcher;
- MockImageReplayer *m_image_replayer;
+ MockImageReplayer *m_image_replayer = nullptr;
};
TEST_F(TestMockImageReplayer, StartStop) {
EXPECT_CALL(mock_remote_journaler, start_live_replay(_, _));
+ MockImageDeleter mock_image_deleter;
+ create_image_replayer(mock_image_deleter);
+
C_SaferCond start_ctx;
m_image_replayer->start(&start_ctx);
ASSERT_EQ(0, start_ctx.wait());
expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
"", 0);
+ MockImageDeleter mock_image_deleter;
+ create_image_replayer(mock_image_deleter);
+
C_SaferCond start_ctx;
m_image_replayer->start(&start_ctx);
ASSERT_EQ(0, start_ctx.wait());
EXPECT_CALL(mock_remote_journaler, remove_listener(_));
expect_shut_down(mock_remote_journaler, 0);
+ MockImageDeleter mock_image_deleter;
+ create_image_replayer(mock_image_deleter);
+
C_SaferCond start_ctx;
m_image_replayer->start(&start_ctx);
ASSERT_EQ(0, start_ctx.wait());
expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
"remote mirror uuid", -EINVAL);
+ MockImageDeleter mock_image_deleter;
+ create_image_replayer(mock_image_deleter);
+
C_SaferCond start_ctx;
m_image_replayer->start(&start_ctx);
ASSERT_EQ(-EINVAL, start_ctx.wait());
EXPECT_CALL(mock_remote_journaler, remove_listener(_));
expect_shut_down(mock_remote_journaler, 0);
+ MockImageDeleter mock_image_deleter;
+ create_image_replayer(mock_image_deleter);
+
C_SaferCond start_ctx;
m_image_replayer->start(&start_ctx);
ASSERT_EQ(-EINVAL, start_ctx.wait());
EXPECT_CALL(mock_remote_journaler, remove_listener(_));
expect_shut_down(mock_remote_journaler, 0);
+ MockImageDeleter mock_image_deleter;
+ create_image_replayer(mock_image_deleter);
+
C_SaferCond start_ctx;
m_image_replayer->start(&start_ctx);
ASSERT_EQ(-EINVAL, start_ctx.wait());
EXPECT_CALL(mock_remote_journaler, start_live_replay(_, _));
+ MockImageDeleter mock_image_deleter;
+ create_image_replayer(mock_image_deleter);
+
C_SaferCond start_ctx;
m_image_replayer->start(&start_ctx);
ASSERT_EQ(0, start_ctx.wait());
EXPECT_CALL(mock_remote_journaler, start_live_replay(_, _));
+ MockImageDeleter mock_image_deleter;
+ create_image_replayer(mock_image_deleter);
+
C_SaferCond start_ctx;
m_image_replayer->start(&start_ctx);
ASSERT_EQ(0, start_ctx.wait());
EXPECT_CALL(mock_remote_journaler, start_live_replay(_, _));
+ MockImageDeleter mock_image_deleter;
+ create_image_replayer(mock_image_deleter);
+
C_SaferCond start_ctx;
m_image_replayer->start(&start_ctx);
ASSERT_EQ(0, start_ctx.wait());
EXPECT_CALL(mock_remote_journaler, start_live_replay(_, _));
+ MockImageDeleter mock_image_deleter;
+ create_image_replayer(mock_image_deleter);
+
C_SaferCond start_ctx;
m_image_replayer->start(&start_ctx);
ASSERT_EQ(0, start_ctx.wait());
#include "test/librbd/mock/MockImageCtx.h"
#include "test/rbd_mirror/test_mock_fixture.h"
+#include "tools/rbd_mirror/ImageDeleter.h"
#include "tools/rbd_mirror/ImageReplayer.h"
#include "tools/rbd_mirror/InstanceWatcher.h"
#include "tools/rbd_mirror/InstanceReplayer.h"
}
};
+template <>
+struct ImageDeleter<librbd::MockTestImageCtx> {
+ MOCK_METHOD3(schedule_image_delete, void(RadosRef, int64_t,
+ const std::string&));
+ MOCK_METHOD4(wait_for_scheduled_deletion,
+ void(int64_t, const std::string&, Context*, bool));
+};
+
template<>
struct InstanceWatcher<librbd::MockTestImageCtx> {
};
static ImageReplayer *create(
Threads<librbd::MockTestImageCtx> *threads,
- std::shared_ptr<ImageDeleter> image_deleter,
+ ImageDeleter<librbd::MockTestImageCtx>* image_deleter,
InstanceWatcher<librbd::MockTestImageCtx> *instance_watcher,
RadosRef local, const std::string &local_mirror_uuid, int64_t local_pool_id,
const std::string &global_image_id) {
using ::testing::Invoke;
using ::testing::Return;
using ::testing::ReturnRef;
+using ::testing::WithArg;
class TestMockInstanceReplayer : public TestMockFixture {
public:
+ typedef ImageDeleter<librbd::MockTestImageCtx> MockImageDeleter;
typedef ImageReplayer<librbd::MockTestImageCtx> MockImageReplayer;
typedef InstanceReplayer<librbd::MockTestImageCtx> MockInstanceReplayer;
typedef InstanceWatcher<librbd::MockTestImageCtx> MockInstanceWatcher;
TestMockFixture::SetUp();
m_mock_threads = new MockThreads(m_threads);
-
- m_image_deleter.reset(
- new rbd::mirror::ImageDeleter(m_threads->work_queue, m_threads->timer,
- &m_threads->timer_lock));
}
void TearDown() override {
TestMockFixture::TearDown();
}
+ void expect_wait_for_scheduled_deletion(MockImageDeleter& mock_image_deleter,
+ const std::string& global_image_id,
+ int r) {
+ EXPECT_CALL(mock_image_deleter,
+ wait_for_scheduled_deletion(_, global_image_id, _, false))
+ .WillOnce(WithArg<2>(Invoke([this, r](Context *ctx) {
+ m_threads->work_queue->queue(ctx, r);
+ })));
+ }
+
MockThreads *m_mock_threads;
- std::shared_ptr<rbd::mirror::ImageDeleter> m_image_deleter;
};
TEST_F(TestMockInstanceReplayer, AcquireReleaseImage) {
+ MockImageDeleter mock_image_deleter;
MockInstanceWatcher mock_instance_watcher;
MockImageReplayer mock_image_replayer;
MockInstanceReplayer instance_replayer(
- m_mock_threads, m_image_deleter,
+ m_mock_threads, &mock_image_deleter,
rbd::mirror::RadosRef(new librados::Rados(m_local_io_ctx)),
"local_mirror_uuid", m_local_io_ctx.get_id());
EXPECT_CALL(mock_image_replayer, is_blacklisted())
.WillRepeatedly(Return(false));
+ expect_wait_for_scheduled_deletion(mock_image_deleter, "global_image_id", 0);
+
InSequence seq;
instance_replayer.init();
* Foundation. See file COPYING.
*
*/
+
#include <boost/bind.hpp>
#include <map>
#include <set>
virtual bool call(Formatter *f, stringstream *ss) = 0;
};
+template <typename I>
class StatusCommand : public ImageDeleterAdminSocketCommand {
public:
- explicit StatusCommand(ImageDeleter *image_del) : image_del(image_del) {}
+ explicit StatusCommand(ImageDeleter<I> *image_del) : image_del(image_del) {}
bool call(Formatter *f, stringstream *ss) override {
image_del->print_status(f, ss);
}
private:
- ImageDeleter *image_del;
+ ImageDeleter<I> *image_del;
};
struct DeleteJournalPolicy : public librbd::journal::Policy {
} // anonymous namespace
+template <typename I>
class ImageDeleterAdminSocketHook : public AdminSocketHook {
public:
- ImageDeleterAdminSocketHook(CephContext *cct, ImageDeleter *image_del) :
+ ImageDeleterAdminSocketHook(CephContext *cct, ImageDeleter<I> *image_del) :
admin_socket(cct->get_admin_socket()) {
std::string command;
r = admin_socket->register_command(command, command, this,
"get status for image deleter");
if (r == 0) {
- commands[command] = new StatusCommand(image_del);
+ commands[command] = new StatusCommand<I>(image_del);
}
}
Commands commands;
};
-ImageDeleter::ImageDeleter(ContextWQ *work_queue, SafeTimer *timer,
- Mutex *timer_lock)
+template <typename I>
+ImageDeleter<I>::ImageDeleter(ContextWQ *work_queue, SafeTimer *timer,
+ Mutex *timer_lock)
: m_running(true),
m_work_queue(work_queue),
m_delete_lock("rbd::mirror::ImageDeleter::Delete"),
m_image_deleter_thread(this),
m_failed_timer(timer),
m_failed_timer_lock(timer_lock),
- m_asok_hook(new ImageDeleterAdminSocketHook(g_ceph_context, this))
+ m_asok_hook(new ImageDeleterAdminSocketHook<I>(g_ceph_context, this))
{
set_failed_timer_interval(g_ceph_context->_conf->rbd_mirror_delete_retry_interval);
m_image_deleter_thread.create("image_deleter");
}
-ImageDeleter::~ImageDeleter() {
+template <typename I>
+ImageDeleter<I>::~ImageDeleter() {
dout(20) << "enter" << dendl;
m_running = false;
dout(20) << "return" << dendl;
}
-void ImageDeleter::run() {
+template <typename I>
+void ImageDeleter<I>::run() {
dout(20) << "enter" << dendl;
while(m_running) {
m_delete_lock.Lock();
}
}
-void ImageDeleter::schedule_image_delete(RadosRef local_rados,
- int64_t local_pool_id,
- const std::string& global_image_id) {
+template <typename I>
+void ImageDeleter<I>::schedule_image_delete(RadosRef local_rados,
+ int64_t local_pool_id,
+ const std::string& global_image_id) {
dout(20) << "enter" << dendl;
Mutex::Locker locker(m_delete_lock);
m_delete_queue_cond.Signal();
}
-void ImageDeleter::wait_for_scheduled_deletion(int64_t local_pool_id,
- const std::string &global_image_id,
- Context *ctx,
- bool notify_on_failed_retry) {
+template <typename I>
+void ImageDeleter<I>::wait_for_scheduled_deletion(int64_t local_pool_id,
+ const std::string &global_image_id,
+ Context *ctx,
+ bool notify_on_failed_retry) {
ctx = new FunctionContext([this, ctx](int r) {
m_work_queue->queue(ctx, r);
(*del_info)->notify_on_failed_retry = notify_on_failed_retry;
}
-void ImageDeleter::cancel_waiter(int64_t local_pool_id,
- const std::string &global_image_id) {
+template <typename I>
+void ImageDeleter<I>::cancel_waiter(int64_t local_pool_id,
+ const std::string &global_image_id) {
Mutex::Locker locker(m_delete_lock);
auto del_info = find_delete_info(local_pool_id, global_image_id);
if (!del_info) {
}
}
-bool ImageDeleter::process_image_delete() {
-
+template <typename I>
+bool ImageDeleter<I>::process_image_delete() {
stringstream ss;
m_active_delete->to_string(ss);
std::string del_info_str = ss.str();
return true;
}
-int ImageDeleter::image_has_snapshots_and_children(IoCtx *ioctx,
- string& image_id,
- bool *has_snapshots) {
-
+template <typename I>
+int ImageDeleter<I>::image_has_snapshots_and_children(IoCtx *ioctx,
+ string& image_id,
+ bool *has_snapshots) {
string header_oid = librbd::util::header_name(image_id);
::SnapContext snapc;
int r = cls_client::get_snapcontext(ioctx, header_oid, &snapc);
return 0;
}
-void ImageDeleter::complete_active_delete(int r) {
+template <typename I>
+void ImageDeleter<I>::complete_active_delete(int r) {
dout(20) << dendl;
Mutex::Locker delete_locker(m_delete_lock);
m_active_delete.reset();
}
-void ImageDeleter::enqueue_failed_delete(int error_code) {
+template <typename I>
+void ImageDeleter<I>::enqueue_failed_delete(int error_code) {
dout(20) << "enter" << dendl;
if (error_code == -EBLACKLISTED) {
m_delete_lock.Unlock();
if (was_empty) {
FunctionContext *ctx = new FunctionContext(
- boost::bind(&ImageDeleter::retry_failed_deletions, this));
+ boost::bind(&ImageDeleter<I>::retry_failed_deletions, this));
Mutex::Locker l(*m_failed_timer_lock);
m_failed_timer->add_event_after(m_failed_interval, ctx);
}
}
-void ImageDeleter::retry_failed_deletions() {
+template <typename I>
+void ImageDeleter<I>::retry_failed_deletions() {
dout(20) << "enter" << dendl;
Mutex::Locker l(m_delete_lock);
}
}
-unique_ptr<ImageDeleter::DeleteInfo> const* ImageDeleter::find_delete_info(
- int64_t local_pool_id, const std::string &global_image_id) {
+template <typename I>
+unique_ptr<typename ImageDeleter<I>::DeleteInfo> const*
+ImageDeleter<I>::find_delete_info(int64_t local_pool_id,
+ const std::string &global_image_id) {
assert(m_delete_lock.is_locked());
if (m_active_delete && m_active_delete->match(local_pool_id,
return nullptr;
}
-void ImageDeleter::print_status(Formatter *f, stringstream *ss) {
+template <typename I>
+void ImageDeleter<I>::print_status(Formatter *f, stringstream *ss) {
dout(20) << "enter" << dendl;
if (f) {
}
}
-void ImageDeleter::DeleteInfo::notify(int r) {
+template <typename I>
+void ImageDeleter<I>::DeleteInfo::notify(int r) {
if (on_delete) {
dout(20) << "executing image deletion handler r=" << r << dendl;
}
}
-void ImageDeleter::DeleteInfo::to_string(stringstream& ss) {
+template <typename I>
+void ImageDeleter<I>::DeleteInfo::to_string(stringstream& ss) {
ss << "[" << "local_pool_id=" << local_pool_id << ", ";
ss << "global_image_id=" << global_image_id << "]";
}
-void ImageDeleter::DeleteInfo::print_status(Formatter *f, stringstream *ss,
- bool print_failure_info) {
+template <typename I>
+void ImageDeleter<I>::DeleteInfo::print_status(Formatter *f, stringstream *ss,
+ bool print_failure_info) {
if (f) {
f->open_object_section("delete_info");
f->dump_int("local_pool_id", local_pool_id);
}
}
-vector<string> ImageDeleter::get_delete_queue_items() {
+template <typename I>
+vector<string> ImageDeleter<I>::get_delete_queue_items() {
vector<string> items;
Mutex::Locker l(m_delete_lock);
return items;
}
-vector<pair<string, int> > ImageDeleter::get_failed_queue_items() {
+template <typename I>
+vector<pair<string, int> > ImageDeleter<I>::get_failed_queue_items() {
vector<pair<string, int> > items;
Mutex::Locker l(m_delete_lock);
return items;
}
-void ImageDeleter::set_failed_timer_interval(double interval) {
+template <typename I>
+void ImageDeleter<I>::set_failed_timer_interval(double interval) {
this->m_failed_interval = interval;
}
} // namespace mirror
} // namespace rbd
+
+template class rbd::mirror::ImageDeleter<librbd::ImageCtx>;
#include <vector>
#include <atomic>
+class AdminSocketHook;
class ContextWQ;
+namespace librbd { struct ImageCtx; }
namespace rbd {
namespace mirror {
-class ImageDeleterAdminSocketHook;
-
/**
* Manage deletion of non-primary images.
*/
+template <typename ImageCtxT = librbd::ImageCtx>
class ImageDeleter {
public:
static const int EISPRM = 1000;
SafeTimer *m_failed_timer;
Mutex *m_failed_timer_lock;
- ImageDeleterAdminSocketHook *m_asok_hook;
+ AdminSocketHook *m_asok_hook;
void run();
bool process_image_delete();
} // namespace mirror
} // namespace rbd
+extern template class rbd::mirror::ImageDeleter<librbd::ImageCtx>;
+
#endif // CEPH_RBD_MIRROR_IMAGEDELETER_H
template <typename I>
ImageReplayer<I>::ImageReplayer(Threads<librbd::ImageCtx> *threads,
- shared_ptr<ImageDeleter> image_deleter,
+ ImageDeleter<I>* image_deleter,
InstanceWatcher<I> *instance_watcher,
RadosRef local,
const std::string &local_mirror_uuid,
};
static ImageReplayer *create(
- Threads<librbd::ImageCtx> *threads,
- std::shared_ptr<ImageDeleter> image_deleter,
+ Threads<librbd::ImageCtx> *threads, ImageDeleter<ImageCtxT>* image_deleter,
InstanceWatcher<ImageCtxT> *instance_watcher,
RadosRef local, const std::string &local_mirror_uuid, int64_t local_pool_id,
const std::string &global_image_id) {
}
ImageReplayer(Threads<librbd::ImageCtx> *threads,
- std::shared_ptr<ImageDeleter> image_deleter,
+ ImageDeleter<ImageCtxT>* image_deleter,
InstanceWatcher<ImageCtxT> *instance_watcher,
RadosRef local, const std::string &local_mirror_uuid,
int64_t local_pool_id, const std::string &global_image_id);
};
Threads<librbd::ImageCtx> *m_threads;
- std::shared_ptr<ImageDeleter> m_image_deleter;
+ ImageDeleter<ImageCtxT>* m_image_deleter;
InstanceWatcher<ImageCtxT> *m_instance_watcher;
RemoteImages m_remote_images;
template <typename I>
InstanceReplayer<I>::InstanceReplayer(
- Threads<I> *threads, std::shared_ptr<ImageDeleter> image_deleter,
+ Threads<I> *threads, ImageDeleter<I>* image_deleter,
RadosRef local_rados, const std::string &local_mirror_uuid,
int64_t local_pool_id)
: m_threads(threads), m_image_deleter(image_deleter),
namespace rbd {
namespace mirror {
-class ImageDeleter;
-
+template <typename> class ImageDeleter;
template <typename> class ImageReplayer;
template <typename> class InstanceWatcher;
template <typename> struct Threads;
class InstanceReplayer {
public:
static InstanceReplayer* create(
- Threads<ImageCtxT> *threads, std::shared_ptr<ImageDeleter> image_deleter,
+ Threads<ImageCtxT> *threads,
+ ImageDeleter<ImageCtxT>* image_deleter,
RadosRef local_rados, const std::string &local_mirror_uuid,
int64_t local_pool_id) {
return new InstanceReplayer(threads, image_deleter, local_rados,
}
InstanceReplayer(Threads<ImageCtxT> *threads,
- std::shared_ptr<ImageDeleter> image_deleter,
+ ImageDeleter<ImageCtxT>* image_deleter,
RadosRef local_rados, const std::string &local_mirror_uuid,
int64_t local_pool_id);
~InstanceReplayer();
typedef std::set<Peer> Peers;
Threads<ImageCtxT> *m_threads;
- std::shared_ptr<ImageDeleter> m_image_deleter;
+ ImageDeleter<ImageCtxT>* m_image_deleter;
RadosRef m_local_rados;
std::string m_local_mirror_uuid;
int64_t m_local_pool_id;
m_local_cluster_watcher.reset(new ClusterWatcher(m_local, m_lock));
- m_image_deleter.reset(new ImageDeleter(m_threads->work_queue,
- m_threads->timer,
- &m_threads->timer_lock));
+ m_image_deleter.reset(new ImageDeleter<>(m_threads->work_queue,
+ m_threads->timer,
+ &m_threads->timer_lock));
return r;
}
if (m_pool_replayers.find(pool_peer) == m_pool_replayers.end()) {
dout(20) << "starting pool replayer for " << peer << dendl;
unique_ptr<PoolReplayer> pool_replayer(new PoolReplayer(
- m_threads, m_image_deleter, kv.first, peer, m_args));
+ m_threads, m_image_deleter.get(), kv.first, peer, m_args));
// TODO: make async, and retry connecting within pool replayer
int r = pool_replayer->init();
// monitor local cluster for config changes in peers
std::unique_ptr<ClusterWatcher> m_local_cluster_watcher;
- std::shared_ptr<ImageDeleter> m_image_deleter;
+ std::unique_ptr<ImageDeleter<>> m_image_deleter;
std::map<PoolPeer, std::unique_ptr<PoolReplayer> > m_pool_replayers;
std::atomic<bool> m_stopping = { false };
bool m_manual_stop = false;
} // anonymous namespace
PoolReplayer::PoolReplayer(Threads<librbd::ImageCtx> *threads,
- std::shared_ptr<ImageDeleter> image_deleter,
+ ImageDeleter<>* image_deleter,
int64_t local_pool_id, const peer_t &peer,
const std::vector<const char*> &args) :
m_threads(threads),
class PoolReplayer {
public:
PoolReplayer(Threads<librbd::ImageCtx> *threads,
- std::shared_ptr<ImageDeleter> image_deleter,
+ ImageDeleter<>* image_deleter,
int64_t local_pool_id, const peer_t &peer,
const std::vector<const char*> &args);
~PoolReplayer();
void handle_update_leader(const std::string &leader_instance_id);
Threads<librbd::ImageCtx> *m_threads;
- std::shared_ptr<ImageDeleter> m_image_deleter;
+ ImageDeleter<>* m_image_deleter;
mutable Mutex m_lock;
Cond m_cond;
std::atomic<bool> m_stopping = { false };
projects / ceph.git / commitdiff