#include "librbd/io/ImageRequestWQ.h"
#include "librbd/io/ReadResult.h"
#include "tools/rbd_mirror/types.h"
-#include "tools/rbd_mirror/ImageDeleter.h"
#include "tools/rbd_mirror/ImageReplayer.h"
#include "tools/rbd_mirror/InstanceWatcher.h"
#include "tools/rbd_mirror/ServiceDaemon.h"
m_service_daemon.reset(new rbd::mirror::ServiceDaemon<>(g_ceph_context,
m_local_cluster,
m_threads.get()));
- m_image_deleter.reset(new rbd::mirror::ImageDeleter<>(
- m_local_ioctx, m_threads.get(), m_service_daemon.get()));
-
- C_SaferCond ctx;
- m_image_deleter->init(&ctx);
- EXPECT_EQ(0, ctx.wait());
m_instance_watcher = rbd::mirror::InstanceWatcher<>::create(
m_local_ioctx, m_threads->work_queue, nullptr);
delete m_replayer;
delete m_instance_watcher;
- C_SaferCond ctx;
- m_image_deleter->shut_down(&ctx);
- ctx.wait();
-
EXPECT_EQ(0, m_remote_cluster.pool_delete(m_remote_pool_name.c_str()));
EXPECT_EQ(0, m_local_cluster->pool_delete(m_local_pool_name.c_str()));
}
template <typename ImageReplayerT = rbd::mirror::ImageReplayer<> >
void create_replayer() {
m_replayer = new ImageReplayerT(
- m_threads.get(), m_image_deleter.get(), m_instance_watcher,
+ m_threads.get(), m_instance_watcher,
rbd::mirror::RadosRef(new librados::Rados(m_local_ioctx)),
m_local_mirror_uuid, m_local_ioctx.get_id(), m_global_image_id);
m_replayer->add_peer("peer uuid", m_remote_ioctx);
std::shared_ptr<librados::Rados> m_local_cluster;
std::unique_ptr<rbd::mirror::Threads<>> m_threads;
std::unique_ptr<rbd::mirror::ServiceDaemon<>> m_service_daemon;
- std::unique_ptr<rbd::mirror::ImageDeleter<>> m_image_deleter;
librados::Rados m_remote_cluster;
rbd::mirror::InstanceWatcher<> *m_instance_watcher;
std::string m_local_mirror_uuid = "local mirror uuid";
m_replayer->resync_image(&ctx);
ASSERT_EQ(0, ctx.wait());
- C_SaferCond delete_ctx;
- m_image_deleter->wait_for_scheduled_deletion(
- m_replayer->get_global_image_id(), &delete_ctx);
- EXPECT_EQ(0, delete_ctx.wait());
+ wait_for_stopped();
C_SaferCond cond;
m_replayer->start(&cond);
ASSERT_EQ(0, cond.wait());
ASSERT_TRUE(m_replayer->is_replaying());
-
wait_for_replay_complete();
open_local_image(&ictx);
ASSERT_TRUE(m_replayer->is_stopped());
- C_SaferCond delete_ctx;
- m_image_deleter->wait_for_scheduled_deletion(
- m_replayer->get_global_image_id(), &delete_ctx);
- EXPECT_EQ(0, delete_ctx.wait());
-
C_SaferCond cond3;
m_replayer->start(&cond3);
ASSERT_EQ(0, cond3.wait());
ASSERT_TRUE(m_replayer->is_stopped());
- C_SaferCond delete_ctx;
- m_image_deleter->wait_for_scheduled_deletion(
- m_replayer->get_global_image_id(), &delete_ctx);
- EXPECT_EQ(0, delete_ctx.wait());
-
C_SaferCond cond2;
m_replayer->start(&cond2);
ASSERT_EQ(0, cond2.wait());
C_SaferCond cond2;
m_replayer->start(&cond2);
ASSERT_EQ(0, cond2.wait());
- C_SaferCond delete_cond;
- m_image_deleter->wait_for_scheduled_deletion(
- m_replayer->get_global_image_id(), &delete_cond);
- EXPECT_EQ(0, delete_cond.wait());
start();
wait_for_replay_complete();
C_SaferCond cond5;
m_replayer->start(&cond5);
ASSERT_EQ(-ENOTCONN, cond5.wait());
- C_SaferCond delete_cond1;
- m_image_deleter->wait_for_scheduled_deletion(
- m_replayer->get_global_image_id(), &delete_cond1);
- EXPECT_EQ(0, delete_cond1.wait());
C_SaferCond cond6;
m_replayer->start(&cond6);
namespace rbd {
namespace mirror {
+template <>
+struct ImageDeleter<librbd::MockTestImageCtx> {
+ static ImageDeleter* s_instance;
+
+ static void trash_move(librados::IoCtx& local_io_ctx,
+ const std::string& global_image_id, bool resync,
+ MockContextWQ* work_queue, Context* on_finish) {
+ assert(s_instance != nullptr);
+ s_instance->trash_move(global_image_id, resync, on_finish);
+ }
+
+ MOCK_METHOD3(trash_move, void(const std::string&, bool, Context*));
+
+ ImageDeleter() {
+ s_instance = this;
+ }
+};
+
+ImageDeleter<librbd::MockTestImageCtx>* ImageDeleter<librbd::MockTestImageCtx>::s_instance = nullptr;
+
template <>
struct Threads<librbd::MockTestImageCtx> {
MockSafeTimer *timer;
}
};
-template <>
-struct ImageDeleter<librbd::MockTestImageCtx> {
- MOCK_METHOD3(schedule_image_delete, void(const std::string&, bool,
- Context*));
- MOCK_METHOD2(wait_for_scheduled_deletion,
- void(const std::string&, Context*));
- MOCK_METHOD1(cancel_waiter, void(const std::string&));
-};
-
template<>
class InstanceWatcher<librbd::MockTestImageCtx> {
};
}));
}
- void expect_wait_for_scheduled_deletion(MockImageDeleter& mock_image_deleter,
- const std::string& global_image_id,
- int r) {
+ void expect_trash_move(MockImageDeleter& mock_image_deleter,
+ const std::string& global_image_id,
+ bool ignore_orphan, int r) {
EXPECT_CALL(mock_image_deleter,
- wait_for_scheduled_deletion(global_image_id, _))
- .WillOnce(WithArg<1>(Invoke([this, r](Context *ctx) {
+ trash_move(global_image_id, ignore_orphan, _))
+ .WillOnce(WithArg<2>(Invoke([this, &mock_image_deleter, r](Context* ctx) {
m_threads->work_queue->queue(ctx, r);
})));
}
- void expect_cancel_waiter(MockImageDeleter& mock_image_deleter) {
- EXPECT_CALL(mock_image_deleter, cancel_waiter("global image id"));
- }
-
- void expect_schedule_image_delete(MockImageDeleter& mock_image_deleter,
- const std::string& global_image_id,
- bool ignore_orphan) {
- EXPECT_CALL(mock_image_deleter,
- schedule_image_delete(global_image_id, ignore_orphan, nullptr));
- }
-
bufferlist encode_tag_data(const librbd::journal::TagData &tag_data) {
bufferlist bl;
::encode(tag_data, bl);
WithArg<2>(CompleteContext(on_commit_r))));
}
- void create_image_replayer(MockThreads &mock_threads,
- MockImageDeleter &mock_image_deleter) {
+ void create_image_replayer(MockThreads &mock_threads) {
m_image_replayer = new MockImageReplayer(
- &mock_threads, &mock_image_deleter, &m_instance_watcher,
+ &mock_threads, &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_peer("peer_uuid", m_remote_io_ctx);
expect_get_or_send_update(mock_replay_status_formatter);
InSequence seq;
- expect_wait_for_scheduled_deletion(mock_image_deleter, "global image id", 0);
expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
"remote mirror uuid", 0);
expect_send(mock_prepare_remote_image_request, "remote mirror uuid",
EXPECT_CALL(mock_remote_journaler, start_live_replay(_, _));
- create_image_replayer(mock_threads, mock_image_deleter);
+ create_image_replayer(mock_threads);
C_SaferCond start_ctx;
m_image_replayer->start(&start_ctx);
MockCloseImageRequest mock_close_local_image_request;
- expect_cancel_waiter(mock_image_deleter);
expect_shut_down(mock_local_replay, true, 0);
EXPECT_CALL(mock_local_journal, remove_listener(_));
EXPECT_CALL(mock_local_journal, stop_external_replay());
expect_get_or_send_update(mock_replay_status_formatter);
InSequence seq;
- expect_wait_for_scheduled_deletion(mock_image_deleter, "global image id", 0);
expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
"", 0);
expect_send(mock_prepare_remote_image_request, "remote mirror uuid",
EXPECT_CALL(mock_remote_journaler, remove_listener(_));
expect_shut_down(mock_remote_journaler, 0);
- create_image_replayer(mock_threads, mock_image_deleter);
+ create_image_replayer(mock_threads);
C_SaferCond start_ctx;
m_image_replayer->start(&start_ctx);
expect_get_or_send_update(mock_replay_status_formatter);
InSequence seq;
- expect_wait_for_scheduled_deletion(mock_image_deleter, "global image id", 0);
expect_send(mock_prepare_local_image_request, "", "", -ENOENT);
expect_send(mock_prepare_remote_image_request, "remote mirror uuid",
m_remote_image_ctx->id, 0);
EXPECT_CALL(mock_remote_journaler, remove_listener(_));
expect_shut_down(mock_remote_journaler, 0);
- create_image_replayer(mock_threads, mock_image_deleter);
+ create_image_replayer(mock_threads);
C_SaferCond start_ctx;
m_image_replayer->start(&start_ctx);
expect_get_or_send_update(mock_replay_status_formatter);
InSequence seq;
- expect_wait_for_scheduled_deletion(mock_image_deleter, "global image id", 0);
expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
"remote mirror uuid", -EINVAL);
- create_image_replayer(mock_threads, mock_image_deleter);
+ create_image_replayer(mock_threads);
C_SaferCond start_ctx;
m_image_replayer->start(&start_ctx);
expect_get_or_send_update(mock_replay_status_formatter);
InSequence seq;
- expect_wait_for_scheduled_deletion(mock_image_deleter, "global image id", 0);
expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
"remote mirror uuid", 0);
expect_send(mock_prepare_remote_image_request, "remote mirror uuid",
"", -ENOENT);
- expect_schedule_image_delete(mock_image_deleter, "global image id", false);
+ expect_trash_move(mock_image_deleter, "global image id", false, 0);
- create_image_replayer(mock_threads, mock_image_deleter);
+ create_image_replayer(mock_threads);
C_SaferCond start_ctx;
m_image_replayer->start(&start_ctx);
expect_get_or_send_update(mock_replay_status_formatter);
InSequence seq;
- expect_wait_for_scheduled_deletion(mock_image_deleter, "global image id", 0);
expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
"some other mirror uuid", 0);
expect_send(mock_prepare_remote_image_request, "remote mirror uuid",
"", -ENOENT);
- create_image_replayer(mock_threads, mock_image_deleter);
+ create_image_replayer(mock_threads);
C_SaferCond start_ctx;
m_image_replayer->start(&start_ctx);
expect_get_or_send_update(mock_replay_status_formatter);
InSequence seq;
- expect_wait_for_scheduled_deletion(mock_image_deleter, "global image id", 0);
expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
"remote mirror uuid", 0);
expect_send(mock_prepare_remote_image_request, "remote mirror uuid",
m_remote_image_ctx->id, -EINVAL);
- create_image_replayer(mock_threads, mock_image_deleter);
+ create_image_replayer(mock_threads);
C_SaferCond start_ctx;
m_image_replayer->start(&start_ctx);
expect_get_or_send_update(mock_replay_status_formatter);
InSequence seq;
- expect_wait_for_scheduled_deletion(mock_image_deleter, "global image id", 0);
expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
"remote mirror uuid", 0);
expect_send(mock_prepare_remote_image_request, "remote mirror uuid",
EXPECT_CALL(mock_remote_journaler, remove_listener(_));
expect_shut_down(mock_remote_journaler, 0);
- create_image_replayer(mock_threads, mock_image_deleter);
+ create_image_replayer(mock_threads);
C_SaferCond start_ctx;
m_image_replayer->start(&start_ctx);
expect_get_or_send_update(mock_replay_status_formatter);
InSequence seq;
- expect_wait_for_scheduled_deletion(mock_image_deleter, "global image id", 0);
expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
"remote mirror uuid", 0);
expect_send(mock_prepare_remote_image_request, "remote mirror uuid",
EXPECT_CALL(mock_remote_journaler, remove_listener(_));
expect_shut_down(mock_remote_journaler, 0);
- create_image_replayer(mock_threads, mock_image_deleter);
+ create_image_replayer(mock_threads);
C_SaferCond start_ctx;
m_image_replayer->start(&start_ctx);
expect_get_or_send_update(mock_replay_status_formatter);
InSequence seq;
- expect_wait_for_scheduled_deletion(mock_image_deleter, "global image id", 0);
expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
"remote mirror uuid", 0);
expect_send(mock_prepare_remote_image_request, "remote mirror uuid",
EXPECT_CALL(mock_remote_journaler, start_live_replay(_, _));
- create_image_replayer(mock_threads, mock_image_deleter);
+ create_image_replayer(mock_threads);
C_SaferCond start_ctx;
m_image_replayer->start(&start_ctx);
MockCloseImageRequest mock_close_local_image_request;
- expect_cancel_waiter(mock_image_deleter);
expect_shut_down(mock_local_replay, true, -EINVAL);
EXPECT_CALL(mock_local_journal, remove_listener(_));
EXPECT_CALL(mock_local_journal, stop_external_replay());
expect_committed(mock_remote_journaler, 2);
InSequence seq;
- expect_wait_for_scheduled_deletion(mock_image_deleter, "global image id", 0);
expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
"remote mirror uuid", 0);
expect_send(mock_prepare_remote_image_request, "remote mirror uuid",
EXPECT_CALL(mock_remote_journaler, start_live_replay(_, _));
- create_image_replayer(mock_threads, mock_image_deleter);
+ create_image_replayer(mock_threads);
C_SaferCond start_ctx;
m_image_replayer->start(&start_ctx);
// STOP
MockCloseImageRequest mock_close_local_image_request;
- expect_cancel_waiter(mock_image_deleter);
expect_shut_down(mock_local_replay, true, 0);
EXPECT_CALL(mock_local_journal, remove_listener(_));
EXPECT_CALL(mock_local_journal, stop_external_replay());
expect_get_commit_tid_in_debug(mock_replay_entry);
InSequence seq;
- expect_wait_for_scheduled_deletion(mock_image_deleter, "global image id", 0);
expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
"remote mirror uuid", 0);
expect_send(mock_prepare_remote_image_request, "remote mirror uuid",
EXPECT_CALL(mock_remote_journaler, start_live_replay(_, _));
- create_image_replayer(mock_threads, mock_image_deleter);
+ create_image_replayer(mock_threads);
C_SaferCond start_ctx;
m_image_replayer->start(&start_ctx);
expect_committed(mock_remote_journaler, 1);
InSequence seq;
- expect_wait_for_scheduled_deletion(mock_image_deleter, "global image id", 0);
expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
"remote mirror uuid", 0);
expect_send(mock_prepare_remote_image_request, "remote mirror uuid",
EXPECT_CALL(mock_remote_journaler, start_live_replay(_, _));
- create_image_replayer(mock_threads, mock_image_deleter);
+ create_image_replayer(mock_threads);
C_SaferCond start_ctx;
m_image_replayer->start(&start_ctx);
MockCloseImageRequest mock_close_local_image_request;
- expect_cancel_waiter(mock_image_deleter);
expect_shut_down(mock_local_replay, true, 0);
EXPECT_CALL(mock_local_journal, remove_listener(_));
EXPECT_CALL(mock_local_journal, stop_external_replay());
#include "test/rbd_mirror/test_mock_fixture.h"
#include "test/rbd_mirror/mock/MockContextWQ.h"
#include "test/rbd_mirror/mock/MockSafeTimer.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> {
-};
-
template<>
struct ServiceDaemon<librbd::MockTestImageCtx> {
MOCK_METHOD3(add_or_update_attribute,
static ImageReplayer *create(
Threads<librbd::MockTestImageCtx> *threads,
- 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) {
class TestMockInstanceReplayer : public TestMockFixture {
public:
typedef Threads<librbd::MockTestImageCtx> MockThreads;
- typedef ImageDeleter<librbd::MockTestImageCtx> MockImageDeleter;
typedef ImageReplayer<librbd::MockTestImageCtx> MockImageReplayer;
typedef InstanceReplayer<librbd::MockTestImageCtx> MockInstanceReplayer;
typedef InstanceWatcher<librbd::MockTestImageCtx> MockInstanceWatcher;
TEST_F(TestMockInstanceReplayer, AcquireReleaseImage) {
MockThreads mock_threads(m_threads);
MockServiceDaemon mock_service_daemon;
- MockImageDeleter mock_image_deleter;
MockInstanceWatcher mock_instance_watcher;
MockImageReplayer mock_image_replayer;
MockInstanceReplayer instance_replayer(
- &mock_threads, &mock_service_daemon, &mock_image_deleter,
+ &mock_threads, &mock_service_daemon,
rbd::mirror::RadosRef(new librados::Rados(m_local_io_ctx)),
"local_mirror_uuid", m_local_io_ctx.get_id());
std::string global_image_id("global_image_id");
TEST_F(TestMockInstanceReplayer, RemoveFinishedImage) {
MockThreads mock_threads(m_threads);
MockServiceDaemon mock_service_daemon;
- MockImageDeleter mock_image_deleter;
MockInstanceWatcher mock_instance_watcher;
MockImageReplayer mock_image_replayer;
MockInstanceReplayer instance_replayer(
- &mock_threads, &mock_service_daemon, &mock_image_deleter,
+ &mock_threads, &mock_service_daemon,
rbd::mirror::RadosRef(new librados::Rados(m_local_io_ctx)),
"local_mirror_uuid", m_local_io_ctx.get_id());
std::string global_image_id("global_image_id");
template <typename I>
ImageReplayer<I>::ImageReplayer(Threads<I> *threads,
- ImageDeleter<I>* image_deleter,
InstanceWatcher<I> *instance_watcher,
RadosRef local,
const std::string &local_mirror_uuid,
int64_t local_pool_id,
const std::string &global_image_id) :
m_threads(threads),
- m_image_deleter(image_deleter),
m_instance_watcher(instance_watcher),
m_local(local),
m_local_mirror_uuid(local_mirror_uuid),
return;
}
- wait_for_deletion();
-}
-
-template <typename I>
-void ImageReplayer<I>::wait_for_deletion() {
- dout(20) << dendl;
-
- Context *ctx = create_context_callback<
- ImageReplayer, &ImageReplayer<I>::handle_wait_for_deletion>(this);
- m_image_deleter->wait_for_scheduled_deletion(m_global_image_id, ctx);
-}
-
-template <typename I>
-void ImageReplayer<I>::handle_wait_for_deletion(int r) {
- dout(20) << "r=" << r << dendl;
-
- if (r == -ECANCELED) {
- on_start_fail(0, "");
- return;
- } else if (r < 0) {
- on_start_fail(r, "error waiting for image deletion");
- return;
- }
-
prepare_local_image();
}
dout(20) << "on_finish=" << on_finish << ", manual=" << manual
<< ", desc=" << desc << dendl;
- m_image_deleter->cancel_waiter(m_global_image_id);
-
image_replayer::BootstrapRequest<I> *bootstrap_request = nullptr;
bool shut_down_replay = false;
bool running = true;
void ImageReplayer<I>::handle_shut_down(int r) {
reschedule_update_status_task(-1);
+ bool resync_requested = false;
+ bool delete_requested = false;
bool unregister_asok_hook = false;
{
Mutex::Locker locker(m_lock);
return;
}
- bool delete_requested = false;
if (m_delete_requested && !m_local_image_id.empty()) {
assert(m_remote_image.image_id.empty());
dout(0) << "remote image no longer exists: scheduling deletion" << dendl;
- delete_requested = true;
+ unregister_asok_hook = true;
+ std::swap(delete_requested, m_delete_requested);
}
- if (delete_requested || m_resync_requested) {
- m_image_deleter->schedule_image_delete(m_global_image_id,
- m_resync_requested, nullptr);
+ std::swap(resync_requested, m_resync_requested);
+ if (delete_requested || resync_requested) {
m_local_image_id = "";
- m_resync_requested = false;
- if (m_delete_requested) {
- unregister_asok_hook = true;
- m_delete_requested = false;
- }
} else if (m_last_r == -ENOENT &&
m_local_image_id.empty() && m_remote_image.image_id.empty()) {
dout(0) << "mirror image no longer exists" << dendl;
unregister_admin_socket_hook();
}
+ if (delete_requested || resync_requested) {
+ dout(5) << "moving image to trash" << dendl;
+ auto ctx = new FunctionContext([this, r](int) {
+ handle_shut_down(r);
+ });
+ ImageDeleter<I>::trash_move(*m_local_ioctx, m_global_image_id,
+ resync_requested, m_threads->work_queue, ctx);
+ return;
+ }
+
dout(20) << "stop complete" << dendl;
ReplayStatusFormatter<I>::destroy(m_replay_status_formatter);
m_replay_status_formatter = nullptr;
namespace rbd {
namespace mirror {
-template <typename> struct ImageDeleter;
template <typename> struct InstanceWatcher;
template <typename> struct Threads;
class ImageReplayer {
public:
static ImageReplayer *create(
- Threads<ImageCtxT> *threads, ImageDeleter<ImageCtxT>* image_deleter,
- InstanceWatcher<ImageCtxT> *instance_watcher,
+ Threads<ImageCtxT> *threads, InstanceWatcher<ImageCtxT> *instance_watcher,
RadosRef local, const std::string &local_mirror_uuid, int64_t local_pool_id,
const std::string &global_image_id) {
- return new ImageReplayer(threads, image_deleter, instance_watcher,
- local, local_mirror_uuid, local_pool_id,
- global_image_id);
+ return new ImageReplayer(threads, instance_watcher, local,
+ local_mirror_uuid, local_pool_id, global_image_id);
}
void destroy() {
delete this;
}
ImageReplayer(Threads<ImageCtxT> *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);
* v *
* <starting> *
* | *
- * v *
- * WAIT_FOR_DELETION *
- * | *
* v (error) *
* PREPARE_LOCAL_IMAGE * * * * * * * * * * * * * * * * * *
* | *
};
Threads<ImageCtxT> *m_threads;
- ImageDeleter<ImageCtxT>* m_image_deleter;
InstanceWatcher<ImageCtxT> *m_instance_watcher;
Peers m_peers;
void handle_shut_down(int r);
void handle_remote_journal_metadata_updated();
- void wait_for_deletion();
- void handle_wait_for_deletion(int r);
-
void prepare_local_image();
void handle_prepare_local_image(int r);
template <typename I>
InstanceReplayer<I>::InstanceReplayer(
Threads<I> *threads, ServiceDaemon<I>* service_daemon,
- ImageDeleter<I>* image_deleter, RadosRef local_rados,
- const std::string &local_mirror_uuid, int64_t local_pool_id)
+ RadosRef local_rados, const std::string &local_mirror_uuid,
+ int64_t local_pool_id)
: m_threads(threads), m_service_daemon(service_daemon),
- m_image_deleter(image_deleter), m_local_rados(local_rados),
- m_local_mirror_uuid(local_mirror_uuid), m_local_pool_id(local_pool_id),
+ m_local_rados(local_rados), m_local_mirror_uuid(local_mirror_uuid),
+ m_local_pool_id(local_pool_id),
m_lock("rbd::mirror::InstanceReplayer " + stringify(local_pool_id)) {
}
auto it = m_image_replayers.find(global_image_id);
if (it == m_image_replayers.end()) {
auto image_replayer = ImageReplayer<I>::create(
- m_threads, m_image_deleter, instance_watcher, m_local_rados,
+ m_threads, instance_watcher, m_local_rados,
m_local_mirror_uuid, m_local_pool_id, global_image_id);
dout(20) << global_image_id << ": creating replayer " << image_replayer
namespace rbd {
namespace mirror {
-template <typename> class ImageDeleter;
template <typename> class ImageReplayer;
template <typename> class InstanceWatcher;
template <typename> class ServiceDaemon;
static InstanceReplayer* create(
Threads<ImageCtxT> *threads,
ServiceDaemon<ImageCtxT>* service_daemon,
- ImageDeleter<ImageCtxT>* image_deleter,
RadosRef local_rados, const std::string &local_mirror_uuid,
int64_t local_pool_id) {
- return new InstanceReplayer(threads, service_daemon, image_deleter,
- local_rados, local_mirror_uuid, local_pool_id);
+ return new InstanceReplayer(threads, service_daemon, local_rados,
+ local_mirror_uuid, local_pool_id);
}
void destroy() {
delete this;
InstanceReplayer(Threads<ImageCtxT> *threads,
ServiceDaemon<ImageCtxT>* service_daemon,
- ImageDeleter<ImageCtxT>* image_deleter,
RadosRef local_rados, const std::string &local_mirror_uuid,
int64_t local_pool_id);
~InstanceReplayer();
Threads<ImageCtxT> *m_threads;
ServiceDaemon<ImageCtxT>* m_service_daemon;
- ImageDeleter<ImageCtxT>* m_image_deleter;
RadosRef m_local_rados;
std::string m_local_mirror_uuid;
int64_t m_local_pool_id;
image_deleter_ctx.wait();
m_instance_replayer.reset(InstanceReplayer<>::create(
- m_threads, m_service_daemon, m_image_deleter.get(), m_local_rados,
- local_mirror_uuid, m_local_pool_id));
+ m_threads, m_service_daemon, m_local_rados, local_mirror_uuid,
+ m_local_pool_id));
m_instance_replayer->init();
m_instance_replayer->add_peer(m_peer.uuid, m_remote_io_ctx);
projects / ceph.git / commitdiff