--- /dev/null
+// -*- mode:C; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab
+/*
+ * Ceph - scalable distributed file system
+ *
+ * Copyright (C) 2016 SUSE LINUX GmbH
+ *
+ * This is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License version 2.1, as published by the Free Software
+ * Foundation. See file COPYING.
+ *
+ */
+#include "include/rados/librados.hpp"
+#include "include/rbd/librbd.hpp"
+#include "include/stringify.h"
+#include "cls/rbd/cls_rbd_client.h"
+#include "tools/rbd_mirror/ImageDeleter.h"
+#include "tools/rbd_mirror/ImageReplayer.h"
+#include "tools/rbd_mirror/Threads.h"
+#include "librbd/ImageCtx.h"
+#include "librbd/ImageState.h"
+#include "librbd/Operations.h"
+#include "librbd/Journal.h"
+#include "librbd/internal.h"
+#include "librbd/Utils.h"
+#include "test/rbd_mirror/test_fixture.h"
+
+#include "test/librados/test.h"
+#include "gtest/gtest.h"
+
+#define GLOBAL_IMAGE_ID "global_image_id"
+#define GLOBAL_CLONE_IMAGE_ID "global_image_id_clone"
+
+#define dout_subsys ceph_subsys_rbd_mirror
+
+using rbd::mirror::RadosRef;
+using rbd::mirror::TestFixture;
+using namespace librbd;
+using cls::rbd::MirrorImageState;
+
+
+void register_test_rbd_mirror_image_deleter() {
+}
+
+class TestImageDeleter : public TestFixture {
+public:
+
+ static int64_t m_local_pool_id;
+
+ const std::string m_local_mirror_uuid = "local mirror uuid";
+ const std::string m_remote_mirror_uuid = "remote mirror uuid";
+
+ static void SetUpTestCase() {
+ TestFixture::SetUpTestCase();
+
+ m_local_pool_id = _rados->pool_lookup(_local_pool_name.c_str());
+ }
+
+ void SetUp() {
+ TestFixture::SetUp();
+
+ librbd::mirror_mode_set(m_local_io_ctx, RBD_MIRROR_MODE_IMAGE);
+
+ m_deleter = new rbd::mirror::ImageDeleter(_rados,
+ 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,
+ false);
+ EXPECT_EQ(0, ictx->state->open());
+ m_local_image_id = ictx->id;
+
+ cls::rbd::MirrorImage mirror_image(GLOBAL_IMAGE_ID,
+ MirrorImageState::MIRROR_IMAGE_STATE_ENABLED);
+ EXPECT_EQ(0, cls_client::mirror_image_set(&m_local_io_ctx, ictx->id,
+ mirror_image));
+
+ demote_image(ictx);
+ EXPECT_EQ(0, ictx->state->close());
+ }
+
+ void TearDown() {
+ remove_image();
+ TestFixture::TearDown();
+ delete m_deleter;
+ }
+
+ void remove_image(bool force=false) {
+ if (!force) {
+ cls::rbd::MirrorImage mirror_image;
+ int r = cls_client::mirror_image_get(&m_local_io_ctx, m_local_image_id,
+ &mirror_image);
+ EXPECT_EQ(1, r == 0 || r == -ENOENT);
+ if (r != -ENOENT) {
+ mirror_image.state = MirrorImageState::MIRROR_IMAGE_STATE_ENABLED;
+ EXPECT_EQ(0, cls_client::mirror_image_set(&m_local_io_ctx,
+ m_local_image_id,
+ mirror_image));
+ }
+ promote_image();
+ }
+ NoOpProgressContext ctx;
+ int r = remove(m_local_io_ctx, m_image_name.c_str(), ctx, force);
+ EXPECT_EQ(1, r == 0 || r == -ENOENT);
+ }
+
+ void promote_image(ImageCtx *ictx=nullptr) {
+ bool close = false;
+ int r = 0;
+ if (!ictx) {
+ ictx = new ImageCtx("", m_local_image_id, "", m_local_io_ctx,
+ false);
+ r = ictx->state->open();
+ close = (r == 0);
+ }
+
+ EXPECT_EQ(1, r == 0 || r == -ENOENT);
+
+ if (r == 0) {
+ int r2 = librbd::mirror_image_promote(ictx, true);
+ EXPECT_EQ(1, r2 == 0 || r2 == -EINVAL);
+ }
+
+ if (close) {
+ EXPECT_EQ(0, ictx->state->close());
+ }
+ }
+
+ void demote_image(ImageCtx *ictx=nullptr) {
+ bool close = false;
+ if (!ictx) {
+ ictx = new ImageCtx("", m_local_image_id, "", m_local_io_ctx,
+ false);
+ EXPECT_EQ(0, ictx->state->open());
+ close = true;
+ }
+
+ EXPECT_EQ(0, librbd::mirror_image_demote(ictx));
+
+ if (close) {
+ EXPECT_EQ(0, ictx->state->close());
+ }
+ }
+
+ void create_snapshot(std::string snap_name="snap1", bool protect=false) {
+ ImageCtx *ictx = new ImageCtx("", m_local_image_id, "", m_local_io_ctx,
+ false);
+ EXPECT_EQ(0, ictx->state->open());
+ promote_image(ictx);
+
+ EXPECT_EQ(0, ictx->operations->snap_create(snap_name.c_str()));
+
+ if (protect) {
+ EXPECT_EQ(0, ictx->operations->snap_protect(snap_name.c_str()));
+ }
+
+ demote_image(ictx);
+ EXPECT_EQ(0, ictx->state->close());
+ }
+
+ std::string create_clone() {
+ ImageCtx *ictx = new ImageCtx("", m_local_image_id, "", m_local_io_ctx,
+ false);
+ EXPECT_EQ(0, ictx->state->open());
+ promote_image(ictx);
+
+ EXPECT_EQ(0, ictx->operations->snap_create("snap1"));
+ EXPECT_EQ(0, ictx->operations->snap_protect("snap1"));
+ int order = 20;
+ EXPECT_EQ(0, librbd::clone(m_local_io_ctx, ictx->name.c_str(), "snap1",
+ m_local_io_ctx, "clone1", ictx->features,
+ &order, 0, 0));
+ std::string clone_id;
+ ImageCtx *ictx_clone = new ImageCtx("clone1", "", "", m_local_io_ctx,
+ false);
+ EXPECT_EQ(0, ictx_clone->state->open());
+ clone_id = ictx_clone->id;
+ cls::rbd::MirrorImage mirror_image(GLOBAL_CLONE_IMAGE_ID,
+ MirrorImageState::MIRROR_IMAGE_STATE_ENABLED);
+ EXPECT_EQ(0, cls_client::mirror_image_set(&m_local_io_ctx, clone_id,
+ mirror_image));
+ demote_image(ictx_clone);
+ EXPECT_EQ(0, ictx_clone->state->close());
+
+ demote_image(ictx);
+ EXPECT_EQ(0, ictx->state->close());
+
+ return clone_id;
+ }
+
+ void check_image_deleted() {
+ ImageCtx *ictx = new ImageCtx("", m_local_image_id, "", m_local_io_ctx,
+ false);
+ EXPECT_EQ(-ENOENT, ictx->state->open());
+ delete ictx;
+
+ cls::rbd::MirrorImage mirror_image;
+ EXPECT_EQ(-ENOENT, cls_client::mirror_image_get(&m_local_io_ctx,
+ m_local_image_id,
+ &mirror_image));
+ }
+
+
+ librbd::RBD rbd;
+ std::string m_local_image_id;
+ rbd::mirror::ImageDeleter *m_deleter;
+};
+
+int64_t TestImageDeleter::m_local_pool_id;
+
+
+TEST_F(TestImageDeleter, Delete_NonPrimary_Image) {
+ m_deleter->schedule_image_delete(m_local_pool_id, m_local_image_id,
+ m_image_name, GLOBAL_IMAGE_ID);
+
+ C_SaferCond ctx;
+ m_deleter->wait_for_scheduled_deletion(m_image_name, &ctx);
+ EXPECT_EQ(0, ctx.wait());
+
+ ASSERT_EQ(0u, m_deleter->get_delete_queue_items().size());
+ ASSERT_EQ(0u, m_deleter->get_failed_queue_items().size());
+
+ check_image_deleted();
+}
+
+TEST_F(TestImageDeleter, Fail_Delete_Primary_Image) {
+ promote_image();
+
+ m_deleter->schedule_image_delete(m_local_pool_id, m_local_image_id,
+ m_image_name, GLOBAL_IMAGE_ID);
+
+ C_SaferCond ctx;
+ m_deleter->wait_for_scheduled_deletion(m_image_name, &ctx);
+ 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());
+}
+
+TEST_F(TestImageDeleter, Fail_Delete_Diff_GlobalId) {
+ // This test case represents a case that should never happen, unless
+ // there is bug in the implementation
+
+ m_deleter->schedule_image_delete(m_local_pool_id, m_local_image_id,
+ m_image_name, "diff global id");
+
+ C_SaferCond ctx;
+ m_deleter->wait_for_scheduled_deletion(m_image_name, &ctx);
+ EXPECT_EQ(-EINVAL, ctx.wait());
+
+ ASSERT_EQ(0u, m_deleter->get_delete_queue_items().size());
+ ASSERT_EQ(0u, m_deleter->get_failed_queue_items().size());
+}
+
+TEST_F(TestImageDeleter, Delete_Image_With_Child) {
+ create_snapshot();
+
+ m_deleter->schedule_image_delete(m_local_pool_id, m_local_image_id,
+ m_image_name, GLOBAL_IMAGE_ID);
+
+ C_SaferCond ctx;
+ m_deleter->wait_for_scheduled_deletion(m_image_name, &ctx);
+ EXPECT_EQ(0, ctx.wait());
+
+ ASSERT_EQ(0u, m_deleter->get_delete_queue_items().size());
+ ASSERT_EQ(0u, m_deleter->get_failed_queue_items().size());
+}
+
+TEST_F(TestImageDeleter, Delete_Image_With_Children) {
+ create_snapshot("snap1");
+ create_snapshot("snap2");
+
+ m_deleter->schedule_image_delete(m_local_pool_id, m_local_image_id,
+ m_image_name, GLOBAL_IMAGE_ID);
+
+ C_SaferCond ctx;
+ m_deleter->wait_for_scheduled_deletion(m_image_name, &ctx);
+ EXPECT_EQ(0, ctx.wait());
+
+ ASSERT_EQ(0u, m_deleter->get_delete_queue_items().size());
+ ASSERT_EQ(0u, m_deleter->get_failed_queue_items().size());
+}
+
+TEST_F(TestImageDeleter, Delete_Image_With_ProtectedChild) {
+ create_snapshot("snap1", true);
+
+ m_deleter->schedule_image_delete(m_local_pool_id, m_local_image_id,
+ m_image_name, GLOBAL_IMAGE_ID);
+
+ C_SaferCond ctx;
+ m_deleter->wait_for_scheduled_deletion(m_image_name, &ctx);
+ EXPECT_EQ(0, ctx.wait());
+
+ ASSERT_EQ(0u, m_deleter->get_delete_queue_items().size());
+ ASSERT_EQ(0u, m_deleter->get_failed_queue_items().size());
+}
+
+TEST_F(TestImageDeleter, Delete_Image_With_ProtectedChildren) {
+ create_snapshot("snap1", true);
+ create_snapshot("snap2", true);
+
+ m_deleter->schedule_image_delete(m_local_pool_id, m_local_image_id,
+ m_image_name, GLOBAL_IMAGE_ID);
+
+ C_SaferCond ctx;
+ m_deleter->wait_for_scheduled_deletion(m_image_name, &ctx);
+ EXPECT_EQ(0, ctx.wait());
+
+ ASSERT_EQ(0u, m_deleter->get_delete_queue_items().size());
+ ASSERT_EQ(0u, m_deleter->get_failed_queue_items().size());
+}
+
+TEST_F(TestImageDeleter, Delete_Image_With_Clone) {
+ std::string clone_id = create_clone();
+
+ m_deleter->schedule_image_delete(m_local_pool_id, m_local_image_id,
+ m_image_name, GLOBAL_IMAGE_ID);
+
+ C_SaferCond ctx;
+ m_deleter->wait_for_scheduled_deletion(m_image_name, &ctx);
+ EXPECT_EQ(-EBUSY, ctx.wait());
+
+ ASSERT_EQ(1u, m_deleter->get_delete_queue_items().size());
+ ASSERT_EQ(0u, m_deleter->get_failed_queue_items().size());
+
+ m_deleter->schedule_image_delete(m_local_pool_id, clone_id,
+ "clone1", GLOBAL_CLONE_IMAGE_ID);
+
+ C_SaferCond ctx2;
+ m_deleter->wait_for_scheduled_deletion("clone1", &ctx2);
+ EXPECT_EQ(0, ctx2.wait());
+
+ C_SaferCond ctx3;
+ m_deleter->wait_for_scheduled_deletion(m_image_name, &ctx3);
+ EXPECT_EQ(0, ctx3.wait());
+
+ ASSERT_EQ(0u, m_deleter->get_delete_queue_items().size());
+ ASSERT_EQ(0u, m_deleter->get_failed_queue_items().size());
+}
+
+TEST_F(TestImageDeleter, Delete_NonExistent_Image) {
+ remove_image();
+
+ m_deleter->schedule_image_delete(m_local_pool_id, m_local_image_id,
+ m_image_name, GLOBAL_IMAGE_ID);
+
+ C_SaferCond ctx;
+ m_deleter->wait_for_scheduled_deletion(m_image_name, &ctx);
+ EXPECT_EQ(0, ctx.wait());
+
+ ASSERT_EQ(0u, m_deleter->get_delete_queue_items().size());
+ ASSERT_EQ(0u, m_deleter->get_failed_queue_items().size());
+
+ check_image_deleted();
+}
+
+TEST_F(TestImageDeleter, Delete_NonExistent_Image_With_MirroringState) {
+ remove_image(true);
+
+ m_deleter->schedule_image_delete(m_local_pool_id, m_local_image_id,
+ m_image_name, GLOBAL_IMAGE_ID);
+
+ C_SaferCond ctx;
+ m_deleter->wait_for_scheduled_deletion(m_image_name, &ctx);
+ EXPECT_EQ(0, ctx.wait());
+
+ ASSERT_EQ(0u, m_deleter->get_delete_queue_items().size());
+ ASSERT_EQ(0u, m_deleter->get_failed_queue_items().size());
+
+ check_image_deleted();
+}
+
+TEST_F(TestImageDeleter, Fail_Delete_NonPrimary_Image) {
+ ImageCtx *ictx = new ImageCtx("", m_local_image_id, "", m_local_io_ctx,
+ false);
+ EXPECT_EQ(0, ictx->state->open());
+
+ m_deleter->schedule_image_delete(m_local_pool_id, m_local_image_id,
+ m_image_name, GLOBAL_IMAGE_ID);
+
+ C_SaferCond ctx;
+ m_deleter->wait_for_scheduled_deletion(m_image_name, &ctx);
+ EXPECT_EQ(-EBUSY, ctx.wait());
+
+ ASSERT_EQ(0u, m_deleter->get_delete_queue_items().size());
+ ASSERT_EQ(1u, m_deleter->get_failed_queue_items().size());
+
+ EXPECT_EQ(0, ictx->state->close());
+}
+
+TEST_F(TestImageDeleter, Retry_Failed_Deletes) {
+ ImageCtx *ictx = new ImageCtx("", m_local_image_id, "", m_local_io_ctx,
+ false);
+ EXPECT_EQ(0, ictx->state->open());
+
+ m_deleter->set_failed_timer_interval(2);
+
+ m_deleter->schedule_image_delete(m_local_pool_id, m_local_image_id,
+ m_image_name, GLOBAL_IMAGE_ID);
+
+ C_SaferCond ctx;
+ m_deleter->wait_for_scheduled_deletion(m_image_name, &ctx);
+ EXPECT_EQ(-EBUSY, ctx.wait());
+
+ EXPECT_EQ(0, ictx->state->close());
+
+ C_SaferCond ctx2;
+ m_deleter->wait_for_scheduled_deletion(m_image_name, &ctx2);
+ EXPECT_EQ(0, ctx2.wait());
+
+ ASSERT_EQ(0u, m_deleter->get_delete_queue_items().size());
+ ASSERT_EQ(0u, m_deleter->get_failed_queue_items().size());
+
+ check_image_deleted();
+}
+
+TEST_F(TestImageDeleter, Delete_Is_Idempotent) {
+ ImageCtx *ictx = new ImageCtx("", m_local_image_id, "", m_local_io_ctx,
+ false);
+ EXPECT_EQ(0, ictx->state->open());
+
+ m_deleter->schedule_image_delete(m_local_pool_id, m_local_image_id,
+ m_image_name, GLOBAL_IMAGE_ID);
+
+ C_SaferCond ctx;
+ m_deleter->wait_for_scheduled_deletion(m_image_name, &ctx);
+ EXPECT_EQ(-EBUSY, ctx.wait());
+
+ ASSERT_EQ(0u, m_deleter->get_delete_queue_items().size());
+ ASSERT_EQ(1u, m_deleter->get_failed_queue_items().size());
+
+ m_deleter->schedule_image_delete(m_local_pool_id, m_local_image_id,
+ m_image_name, GLOBAL_IMAGE_ID);
+
+ ASSERT_EQ(0u, m_deleter->get_delete_queue_items().size());
+ ASSERT_EQ(1u, m_deleter->get_failed_queue_items().size());
+
+ EXPECT_EQ(0, ictx->state->close());
+}
+
+
projects / ceph.git / commitdiff