src/ceph/src/test/rbd_mirror/image_sync/test_mock_ImageCopyRequest.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3
   4 #include "test/rbd_mirror/test_mock_fixture.h"
   5 #include "include/rbd/librbd.hpp"
   6 #include "librbd/ImageCtx.h"
   7 #include "librbd/ImageState.h"
   8 #include "librbd/Operations.h"
   9 #include "librbd/journal/TypeTraits.h"
  10 #include "test/journal/mock/MockJournaler.h"
  11 #include "test/librados_test_stub/MockTestMemIoCtxImpl.h"
  12 #include "test/librbd/mock/MockImageCtx.h"
  13 #include "tools/rbd_mirror/image_sync/ImageCopyRequest.h"
  14 #include "tools/rbd_mirror/image_sync/ObjectCopyRequest.h"
  15 #include "tools/rbd_mirror/Threads.h"
  16 #include <boost/scope_exit.hpp>
  17
  18 namespace librbd {
  19
  20 namespace {
  21
  22 struct MockTestImageCtx : public librbd::MockImageCtx {
  23   MockTestImageCtx(librbd::ImageCtx &image_ctx)
  24     : librbd::MockImageCtx(image_ctx) {
  25   }
  26 };
  27
  28 } // anonymous namespace
  29
  30 namespace journal {
  31
  32 template <>
  33 struct TypeTraits<librbd::MockTestImageCtx> {
  34   typedef ::journal::MockJournaler Journaler;
  35 };
  36
  37 } // namespace journal
  38 } // namespace librbd
  39
  40 namespace rbd {
  41 namespace mirror {
  42 namespace image_sync {
  43
  44 template <>
  45 struct ObjectCopyRequest<librbd::MockTestImageCtx> {
  46   static ObjectCopyRequest* s_instance;
  47   static ObjectCopyRequest* create(librbd::MockTestImageCtx *local_image_ctx,
  48                                    librbd::MockTestImageCtx *remote_image_ctx,
  49                                    const ImageCopyRequest<librbd::MockTestImageCtx>::SnapMap *snap_map,
  50                                    uint64_t object_number, Context *on_finish) {
  51     assert(s_instance != nullptr);
  52     Mutex::Locker locker(s_instance->lock);
  53     s_instance->snap_map = snap_map;
  54     s_instance->object_contexts[object_number] = on_finish;
  55     s_instance->cond.Signal();
  56     return s_instance;
  57   }
  58
  59   MOCK_METHOD0(send, void());
  60
  61   Mutex lock;
  62   Cond cond;
  63
  64   const ImageCopyRequest<librbd::MockTestImageCtx>::SnapMap *snap_map = nullptr;
  65   std::map<uint64_t, Context *> object_contexts;
  66
  67   ObjectCopyRequest() : lock("lock") {
  68     s_instance = this;
  69   }
  70 };
  71
  72 ObjectCopyRequest<librbd::MockTestImageCtx>* ObjectCopyRequest<librbd::MockTestImageCtx>::s_instance = nullptr;
  73
  74 } // namespace image_sync
  75 } // namespace mirror
  76 } // namespace rbd
  77
  78 // template definitions
  79 #include "tools/rbd_mirror/image_sync/ImageCopyRequest.cc"
  80 template class rbd::mirror::image_sync::ImageCopyRequest<librbd::MockTestImageCtx>;
  81
  82 namespace rbd {
  83 namespace mirror {
  84 namespace image_sync {
  85
  86 using ::testing::_;
  87 using ::testing::InSequence;
  88 using ::testing::Invoke;
  89 using ::testing::Return;
  90 using ::testing::WithArg;
  91 using ::testing::InvokeWithoutArgs;
  92
  93 class TestMockImageSyncImageCopyRequest : public TestMockFixture {
  94 public:
  95   typedef ImageCopyRequest<librbd::MockTestImageCtx> MockImageCopyRequest;
  96   typedef ObjectCopyRequest<librbd::MockTestImageCtx> MockObjectCopyRequest;
  97
  98   void SetUp() override {
  99     TestMockFixture::SetUp();
 100
 101     librbd::RBD rbd;
 102     ASSERT_EQ(0, create_image(rbd, m_remote_io_ctx, m_image_name, m_image_size));
 103     ASSERT_EQ(0, open_image(m_remote_io_ctx, m_image_name, &m_remote_image_ctx));
 104
 105     ASSERT_EQ(0, create_image(rbd, m_local_io_ctx, m_image_name, m_image_size));
 106     ASSERT_EQ(0, open_image(m_local_io_ctx, m_image_name, &m_local_image_ctx));
 107   }
 108
 109   void expect_get_snap_id(librbd::MockTestImageCtx &mock_image_ctx) {
 110     EXPECT_CALL(mock_image_ctx, get_snap_id(_, _))
 111       .WillRepeatedly(Invoke([&mock_image_ctx](cls::rbd::SnapshotNamespace snap_namespace,
 112                                                std::string snap_name) {
 113         assert(mock_image_ctx.image_ctx->snap_lock.is_locked());
 114         return mock_image_ctx.image_ctx->get_snap_id(snap_namespace, snap_name);
 115       }));
 116   }
 117
 118   void expect_get_object_count(librbd::MockTestImageCtx &mock_image_ctx,
 119                                uint64_t count) {
 120     EXPECT_CALL(mock_image_ctx, get_object_count(_))
 121       .WillOnce(Return(count)).RetiresOnSaturation();
 122   }
 123
 124   void expect_update_client(journal::MockJournaler &mock_journaler, int r) {
 125     EXPECT_CALL(mock_journaler, update_client(_, _))
 126       .WillOnce(WithArg<1>(CompleteContext(r)));
 127   }
 128
 129   void expect_object_copy_send(MockObjectCopyRequest &mock_object_copy_request) {
 130     EXPECT_CALL(mock_object_copy_request, send());
 131   }
 132
 133   bool complete_object_copy(MockObjectCopyRequest &mock_object_copy_request,
 134                                uint64_t object_num, int r,
 135                                std::function<void()> fn = []() {}) {
 136     Mutex::Locker locker(mock_object_copy_request.lock);
 137     while (mock_object_copy_request.object_contexts.count(object_num) == 0) {
 138       if (mock_object_copy_request.cond.WaitInterval(mock_object_copy_request.lock,
 139                                                      utime_t(10, 0)) != 0) {
 140         return false;
 141       }
 142     }
 143
 144     FunctionContext *wrapper_ctx = new FunctionContext(
 145       [&mock_object_copy_request, object_num, fn] (int r) {
 146         fn();
 147         mock_object_copy_request.object_contexts[object_num]->complete(r);
 148       });
 149     m_threads->work_queue->queue(wrapper_ctx, r);
 150     return true;
 151   }
 152
 153   MockImageCopyRequest::SnapMap wait_for_snap_map(MockObjectCopyRequest &mock_object_copy_request) {
 154     Mutex::Locker locker(mock_object_copy_request.lock);
 155     while (mock_object_copy_request.snap_map == nullptr) {
 156       if (mock_object_copy_request.cond.WaitInterval(mock_object_copy_request.lock,
 157                                                      utime_t(10, 0)) != 0) {
 158         return MockImageCopyRequest::SnapMap();
 159       }
 160     }
 161     return *mock_object_copy_request.snap_map;
 162   }
 163
 164   MockImageCopyRequest *create_request(librbd::MockTestImageCtx &mock_remote_image_ctx,
 165                                        librbd::MockTestImageCtx &mock_local_image_ctx,
 166                                        journal::MockJournaler &mock_journaler,
 167                                        librbd::journal::MirrorPeerSyncPoint &sync_point,
 168                                        Context *ctx) {
 169     return new MockImageCopyRequest(&mock_local_image_ctx,
 170                                     &mock_remote_image_ctx,
 171                                     m_threads->timer, &m_threads->timer_lock,
 172                                     &mock_journaler, &m_client_meta,
 173                                     &sync_point, ctx);
 174   }
 175
 176   using TestFixture::create_snap;
 177   int create_snap(const char* snap_name) {
 178     librados::snap_t remote_snap_id;
 179     int r = create_snap(m_remote_image_ctx, snap_name, &remote_snap_id);
 180     if (r < 0) {
 181       return r;
 182     }
 183
 184     librados::snap_t local_snap_id;
 185     r = create_snap(m_local_image_ctx, snap_name, &local_snap_id);
 186     if (r < 0) {
 187       return r;
 188     }
 189
 190     // collection of all existing snaps in local image
 191     MockImageCopyRequest::SnapIds local_snap_ids({local_snap_id});
 192     if (!m_snap_map.empty()) {
 193       local_snap_ids.insert(local_snap_ids.end(),
 194                             m_snap_map.rbegin()->second.begin(),
 195                             m_snap_map.rbegin()->second.end());
 196     }
 197     m_snap_map[remote_snap_id] = local_snap_ids;
 198     m_client_meta.snap_seqs[remote_snap_id] = local_snap_id;
 199     return 0;
 200   }
 201
 202   librbd::ImageCtx *m_remote_image_ctx;
 203   librbd::ImageCtx *m_local_image_ctx;
 204   librbd::journal::MirrorPeerClientMeta m_client_meta;
 205   MockImageCopyRequest::SnapMap m_snap_map;
 206 };
 207
 208 TEST_F(TestMockImageSyncImageCopyRequest, SimpleImage) {
 209   ASSERT_EQ(0, create_snap("snap1"));
 210   m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(),
 211                                 "snap1",
 212                                 boost::none}};
 213
 214   librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
 215   librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
 216   journal::MockJournaler mock_journaler;
 217   MockObjectCopyRequest mock_object_copy_request;
 218
 219   expect_get_snap_id(mock_remote_image_ctx);
 220
 221   InSequence seq;
 222   expect_get_object_count(mock_remote_image_ctx, 1);
 223   expect_get_object_count(mock_remote_image_ctx, 0);
 224   expect_update_client(mock_journaler, 0);
 225   expect_object_copy_send(mock_object_copy_request);
 226   expect_update_client(mock_journaler, 0);
 227
 228   C_SaferCond ctx;
 229   MockImageCopyRequest *request = create_request(mock_remote_image_ctx,
 230                                                  mock_local_image_ctx,
 231                                                  mock_journaler,
 232                                                  m_client_meta.sync_points.front(),
 233                                                  &ctx);
 234   request->send();
 235
 236   ASSERT_EQ(m_snap_map, wait_for_snap_map(mock_object_copy_request));
 237   ASSERT_TRUE(complete_object_copy(mock_object_copy_request, 0, 0));
 238   ASSERT_EQ(0, ctx.wait());
 239 }
 240
 241 TEST_F(TestMockImageSyncImageCopyRequest, Throttled) {
 242   ASSERT_EQ(0, create_snap("snap1"));
 243   m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(),
 244                                 "snap1",
 245                                 boost::none}};
 246
 247   std::string update_sync_age;;
 248   ASSERT_EQ(0, _rados->conf_get("rbd_mirror_sync_point_update_age", update_sync_age));
 249   ASSERT_EQ(0, _rados->conf_set("rbd_mirror_sync_point_update_age", "1"));
 250   BOOST_SCOPE_EXIT( (update_sync_age) ) {
 251     ASSERT_EQ(0, _rados->conf_set("rbd_mirror_sync_point_update_age", update_sync_age.c_str()));
 252   } BOOST_SCOPE_EXIT_END;
 253
 254
 255   std::string max_ops_str;
 256   ASSERT_EQ(0, _rados->conf_get("rbd_concurrent_management_ops", max_ops_str));
 257   int max_ops = std::stoi(max_ops_str);
 258
 259   uint64_t object_count = 55;
 260
 261   librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
 262   librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
 263   journal::MockJournaler mock_journaler;
 264   MockObjectCopyRequest mock_object_copy_request;
 265
 266   expect_get_snap_id(mock_remote_image_ctx);
 267
 268   expect_get_object_count(mock_remote_image_ctx, object_count);
 269   expect_get_object_count(mock_remote_image_ctx, 0);
 270
 271   EXPECT_CALL(mock_object_copy_request, send()).Times(object_count);
 272
 273   boost::optional<uint64_t> expected_object_number(boost::none);
 274   EXPECT_CALL(mock_journaler, update_client(_, _))
 275     .WillRepeatedly(
 276         Invoke([&expected_object_number, max_ops, object_count, this]
 277                (bufferlist data, Context *ctx) {
 278           ASSERT_EQ(expected_object_number,
 279                     m_client_meta.sync_points.front().object_number);
 280           if (!expected_object_number) {
 281             expected_object_number = (max_ops - 1);
 282           } else {
 283             expected_object_number = expected_object_number.get() + max_ops;
 284           }
 285
 286           if (expected_object_number.get() > (object_count - 1)) {
 287             expected_object_number = (object_count - 1);
 288           }
 289
 290           m_threads->work_queue->queue(ctx, 0);
 291       }));
 292
 293
 294   C_SaferCond ctx;
 295   MockImageCopyRequest *request = create_request(mock_remote_image_ctx,
 296                                                  mock_local_image_ctx,
 297                                                  mock_journaler,
 298                                                  m_client_meta.sync_points.front(),
 299                                                  &ctx);
 300   request->send();
 301
 302   std::function<void()> sleep_fn = [request]() {
 303     sleep(2);
 304   };
 305
 306   ASSERT_EQ(m_snap_map, wait_for_snap_map(mock_object_copy_request));
 307   for (uint64_t i = 0; i < object_count; ++i) {
 308     if (i % 10 == 0) {
 309       ASSERT_TRUE(complete_object_copy(mock_object_copy_request, i, 0, sleep_fn));
 310     } else {
 311       ASSERT_TRUE(complete_object_copy(mock_object_copy_request, i, 0));
 312     }
 313   }
 314   ASSERT_EQ(0, ctx.wait());
 315 }
 316
 317 TEST_F(TestMockImageSyncImageCopyRequest, SnapshotSubset) {
 318   ASSERT_EQ(0, create_snap("snap1"));
 319   ASSERT_EQ(0, create_snap("snap2"));
 320   ASSERT_EQ(0, create_snap("snap3"));
 321   m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(),
 322                                 "snap3", "snap2", boost::none}};
 323
 324   librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
 325   librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
 326   journal::MockJournaler mock_journaler;
 327   MockObjectCopyRequest mock_object_copy_request;
 328
 329   expect_get_snap_id(mock_remote_image_ctx);
 330
 331   InSequence seq;
 332   expect_get_object_count(mock_remote_image_ctx, 1);
 333   expect_get_object_count(mock_remote_image_ctx, 0);
 334   expect_get_object_count(mock_remote_image_ctx, 1);
 335   expect_get_object_count(mock_remote_image_ctx, 1);
 336   expect_update_client(mock_journaler, 0);
 337   expect_object_copy_send(mock_object_copy_request);
 338   expect_update_client(mock_journaler, 0);
 339
 340   C_SaferCond ctx;
 341   MockImageCopyRequest *request = create_request(mock_remote_image_ctx,
 342                                                  mock_local_image_ctx,
 343                                                  mock_journaler,
 344                                                  m_client_meta.sync_points.front(),
 345                                                  &ctx);
 346   request->send();
 347
 348   MockImageCopyRequest::SnapMap snap_map(m_snap_map);
 349   snap_map.erase(snap_map.begin());
 350   ASSERT_EQ(snap_map, wait_for_snap_map(mock_object_copy_request));
 351
 352   ASSERT_TRUE(complete_object_copy(mock_object_copy_request, 0, 0));
 353   ASSERT_EQ(0, ctx.wait());
 354 }
 355
 356 TEST_F(TestMockImageSyncImageCopyRequest, RestartCatchup) {
 357   ASSERT_EQ(0, create_snap("snap1"));
 358   ASSERT_EQ(0, create_snap("snap2"));
 359   m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(), "snap1", boost::none},
 360                                {cls::rbd::UserSnapshotNamespace(), "snap2", "snap1", boost::none}};
 361
 362   librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
 363   librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
 364   journal::MockJournaler mock_journaler;
 365   MockObjectCopyRequest mock_object_copy_request;
 366
 367   expect_get_snap_id(mock_remote_image_ctx);
 368
 369   InSequence seq;
 370   expect_get_object_count(mock_remote_image_ctx, 1);
 371   expect_get_object_count(mock_remote_image_ctx, 0);
 372   expect_get_object_count(mock_remote_image_ctx, 0);
 373   expect_update_client(mock_journaler, 0);
 374   expect_object_copy_send(mock_object_copy_request);
 375   expect_update_client(mock_journaler, 0);
 376
 377   C_SaferCond ctx;
 378   MockImageCopyRequest *request = create_request(mock_remote_image_ctx,
 379                                                  mock_local_image_ctx,
 380                                                  mock_journaler,
 381                                                  m_client_meta.sync_points.back(),
 382                                                  &ctx);
 383   request->send();
 384
 385   ASSERT_EQ(m_snap_map, wait_for_snap_map(mock_object_copy_request));
 386   ASSERT_TRUE(complete_object_copy(mock_object_copy_request, 0, 0));
 387   ASSERT_EQ(0, ctx.wait());
 388 }
 389
 390 TEST_F(TestMockImageSyncImageCopyRequest, RestartPartialSync) {
 391   ASSERT_EQ(0, create_snap("snap1"));
 392   m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(),
 393                                 "snap1",
 394                                 librbd::journal::MirrorPeerSyncPoint::ObjectNumber{0U}}};
 395
 396   librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
 397   librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
 398   journal::MockJournaler mock_journaler;
 399   MockObjectCopyRequest mock_object_copy_request;
 400
 401   expect_get_snap_id(mock_remote_image_ctx);
 402
 403   InSequence seq;
 404   expect_get_object_count(mock_remote_image_ctx, 1);
 405   expect_get_object_count(mock_remote_image_ctx, 2);
 406   expect_update_client(mock_journaler, 0);
 407   expect_object_copy_send(mock_object_copy_request);
 408   expect_update_client(mock_journaler, 0);
 409
 410   C_SaferCond ctx;
 411   MockImageCopyRequest *request = create_request(mock_remote_image_ctx,
 412                                                  mock_local_image_ctx,
 413                                                  mock_journaler,
 414                                                  m_client_meta.sync_points.front(),
 415                                                  &ctx);
 416   request->send();
 417
 418   ASSERT_TRUE(complete_object_copy(mock_object_copy_request, 1, 0));
 419   ASSERT_EQ(0, ctx.wait());
 420 }
 421
 422 TEST_F(TestMockImageSyncImageCopyRequest, Cancel) {
 423   std::string max_ops_str;
 424   ASSERT_EQ(0, _rados->conf_get("rbd_concurrent_management_ops", max_ops_str));
 425   ASSERT_EQ(0, _rados->conf_set("rbd_concurrent_management_ops", "1"));
 426   BOOST_SCOPE_EXIT( (max_ops_str) ) {
 427     ASSERT_EQ(0, _rados->conf_set("rbd_concurrent_management_ops", max_ops_str.c_str()));
 428   } BOOST_SCOPE_EXIT_END;
 429
 430   ASSERT_EQ(0, create_snap("snap1"));
 431   m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(), "snap1", boost::none}};
 432
 433   librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
 434   librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
 435   journal::MockJournaler mock_journaler;
 436   MockObjectCopyRequest mock_object_copy_request;
 437
 438   expect_get_snap_id(mock_remote_image_ctx);
 439
 440   InSequence seq;
 441   expect_get_object_count(mock_remote_image_ctx, 2);
 442   expect_get_object_count(mock_remote_image_ctx, 2);
 443   expect_update_client(mock_journaler, 0);
 444   expect_object_copy_send(mock_object_copy_request);
 445
 446   C_SaferCond ctx;
 447   MockImageCopyRequest *request = create_request(mock_remote_image_ctx,
 448                                                  mock_local_image_ctx,
 449                                                  mock_journaler,
 450                                                  m_client_meta.sync_points.front(),
 451                                                  &ctx);
 452   request->send();
 453
 454   ASSERT_EQ(m_snap_map, wait_for_snap_map(mock_object_copy_request));
 455   request->cancel();
 456
 457   ASSERT_TRUE(complete_object_copy(mock_object_copy_request, 0, 0));
 458   ASSERT_EQ(-ECANCELED, ctx.wait());
 459 }
 460
 461 TEST_F(TestMockImageSyncImageCopyRequest, Cancel_Inflight_Sync) {
 462   std::string update_sync_age;;
 463   ASSERT_EQ(0, _rados->conf_get("rbd_mirror_sync_point_update_age", update_sync_age));
 464   ASSERT_EQ(0, _rados->conf_set("rbd_mirror_sync_point_update_age", "1"));
 465   BOOST_SCOPE_EXIT( (update_sync_age) ) {
 466     ASSERT_EQ(0, _rados->conf_set("rbd_mirror_sync_point_update_age", update_sync_age.c_str()));
 467   } BOOST_SCOPE_EXIT_END;
 468
 469   std::string max_ops_str;
 470   ASSERT_EQ(0, _rados->conf_get("rbd_concurrent_management_ops", max_ops_str));
 471   ASSERT_EQ(0, _rados->conf_set("rbd_concurrent_management_ops", "3"));
 472   BOOST_SCOPE_EXIT( (max_ops_str) ) {
 473     ASSERT_EQ(0, _rados->conf_set("rbd_concurrent_management_ops", max_ops_str.c_str()));
 474   } BOOST_SCOPE_EXIT_END;
 475
 476   ASSERT_EQ(0, create_snap("snap1"));
 477   m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(), "snap1", boost::none}};
 478
 479   librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
 480   librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
 481   journal::MockJournaler mock_journaler;
 482   MockObjectCopyRequest mock_object_copy_request;
 483
 484   expect_get_snap_id(mock_remote_image_ctx);
 485
 486   expect_get_object_count(mock_remote_image_ctx, 10);
 487   expect_get_object_count(mock_remote_image_ctx, 0);
 488
 489   EXPECT_CALL(mock_object_copy_request, send()).Times(6);
 490
 491   EXPECT_CALL(mock_journaler, update_client(_, _))
 492     .WillRepeatedly(Invoke([this] (bufferlist data, Context *ctx) {
 493           m_threads->work_queue->queue(ctx, 0);
 494       }));
 495
 496
 497   C_SaferCond ctx;
 498   MockImageCopyRequest *request = create_request(mock_remote_image_ctx,
 499                                                  mock_local_image_ctx,
 500                                                  mock_journaler,
 501                                                  m_client_meta.sync_points.front(),
 502                                                  &ctx);
 503   request->send();
 504
 505   ASSERT_EQ(m_snap_map, wait_for_snap_map(mock_object_copy_request));
 506
 507   std::function<void()> cancel_fn = [request]() {
 508     sleep(2);
 509     request->cancel();
 510   };
 511
 512   ASSERT_TRUE(complete_object_copy(mock_object_copy_request, 0, 0));
 513   ASSERT_TRUE(complete_object_copy(mock_object_copy_request, 1, 0));
 514   ASSERT_TRUE(complete_object_copy(mock_object_copy_request, 2, 0));
 515   ASSERT_TRUE(complete_object_copy(mock_object_copy_request, 3, 0, cancel_fn));
 516   ASSERT_TRUE(complete_object_copy(mock_object_copy_request, 4, 0));
 517   ASSERT_TRUE(complete_object_copy(mock_object_copy_request, 5, 0));
 518
 519   ASSERT_EQ(-ECANCELED, ctx.wait());
 520   ASSERT_EQ(5u, m_client_meta.sync_points.front().object_number.get());
 521 }
 522
 523 TEST_F(TestMockImageSyncImageCopyRequest, Cancel1) {
 524   ASSERT_EQ(0, create_snap("snap1"));
 525   m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(), "snap1", boost::none}};
 526
 527   librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
 528   librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
 529   journal::MockJournaler mock_journaler;
 530   MockObjectCopyRequest mock_object_copy_request;
 531
 532   C_SaferCond ctx;
 533   MockImageCopyRequest *request = create_request(mock_remote_image_ctx,
 534                                                  mock_local_image_ctx,
 535                                                  mock_journaler,
 536                                                  m_client_meta.sync_points.front(),
 537                                                  &ctx);
 538
 539   expect_get_snap_id(mock_remote_image_ctx);
 540
 541   InSequence seq;
 542   expect_get_object_count(mock_remote_image_ctx, 1);
 543   expect_get_object_count(mock_remote_image_ctx, 0);
 544   EXPECT_CALL(mock_journaler, update_client(_, _))
 545     .WillOnce(DoAll(InvokeWithoutArgs([request]() {
 546             request->cancel();
 547           }),
 548         WithArg<1>(CompleteContext(0))));
 549
 550   request->send();
 551   ASSERT_EQ(-ECANCELED, ctx.wait());
 552 }
 553
 554 TEST_F(TestMockImageSyncImageCopyRequest, MissingSnap) {
 555   ASSERT_EQ(0, create_snap("snap1"));
 556   m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(), "missing-snap", boost::none}};
 557
 558   librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
 559   librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
 560   journal::MockJournaler mock_journaler;
 561
 562   expect_get_snap_id(mock_remote_image_ctx);
 563
 564   C_SaferCond ctx;
 565   MockImageCopyRequest *request = create_request(mock_remote_image_ctx,
 566                                                  mock_local_image_ctx,
 567                                                  mock_journaler,
 568                                                  m_client_meta.sync_points.front(),
 569                                                  &ctx);
 570   request->send();
 571   ASSERT_EQ(-ENOENT, ctx.wait());
 572 }
 573
 574 TEST_F(TestMockImageSyncImageCopyRequest, MissingFromSnap) {
 575   ASSERT_EQ(0, create_snap("snap1"));
 576   m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(),
 577                                 "snap1",
 578                                 "missing-snap",
 579                                 boost::none}};
 580
 581   librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
 582   librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
 583   journal::MockJournaler mock_journaler;
 584
 585   expect_get_snap_id(mock_remote_image_ctx);
 586
 587   C_SaferCond ctx;
 588   MockImageCopyRequest *request = create_request(mock_remote_image_ctx,
 589                                                  mock_local_image_ctx,
 590                                                  mock_journaler,
 591                                                  m_client_meta.sync_points.front(),
 592                                                  &ctx);
 593   request->send();
 594   ASSERT_EQ(-ENOENT, ctx.wait());
 595 }
 596
 597 TEST_F(TestMockImageSyncImageCopyRequest, EmptySnapMap) {
 598   ASSERT_EQ(0, create_snap("snap1"));
 599   ASSERT_EQ(0, create_snap("snap2"));
 600   m_client_meta.snap_seqs = {{0, 0}};
 601   m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(),
 602                                 "snap2",
 603                                 "snap1",
 604                                 boost::none}};
 605
 606   librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
 607   librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
 608   journal::MockJournaler mock_journaler;
 609
 610   expect_get_snap_id(mock_remote_image_ctx);
 611
 612   C_SaferCond ctx;
 613   MockImageCopyRequest *request = create_request(mock_remote_image_ctx,
 614                                                  mock_local_image_ctx,
 615                                                  mock_journaler,
 616                                                  m_client_meta.sync_points.front(),
 617                                                  &ctx);
 618   request->send();
 619   ASSERT_EQ(-EINVAL, ctx.wait());
 620 }
 621
 622 TEST_F(TestMockImageSyncImageCopyRequest, EmptySnapSeqs) {
 623   ASSERT_EQ(0, create_snap("snap1"));
 624   ASSERT_EQ(0, create_snap("snap2"));
 625   m_client_meta.snap_seqs = {};
 626   m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(),
 627                                 "snap2",
 628                                 "snap1",
 629                                 boost::none}};
 630
 631   librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
 632   librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
 633   journal::MockJournaler mock_journaler;
 634
 635   expect_get_snap_id(mock_remote_image_ctx);
 636
 637   C_SaferCond ctx;
 638   MockImageCopyRequest *request = create_request(mock_remote_image_ctx,
 639                                                  mock_local_image_ctx,
 640                                                  mock_journaler,
 641                                                  m_client_meta.sync_points.front(),
 642                                                  &ctx);
 643   request->send();
 644   ASSERT_EQ(-EINVAL, ctx.wait());
 645 }
 646
 647 } // namespace image_sync
 648 } // namespace mirror
 649 } // namespace rbd