ceph/src/test/objectstore/test_memstore_clone.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3 /*
   4  * Ceph - scalable distributed file system
   5  *
   6  * Copyright (C) 2015 Red Hat
   7  *
   8  * This is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License version 2.1, as published by the Free Software
  11  * Foundation. See file COPYING.
  12  *
  13  */
  14 #include <boost/intrusive_ptr.hpp>
  15 #include "global/global_init.h"
  16 #include "common/ceph_argparse.h"
  17 #include "os/ObjectStore.h"
  18 #include <gtest/gtest.h>
  19 #include "include/assert.h"
  20 #include "common/errno.h"
  21 #include "store_test_fixture.h"
  22
  23 #define dout_context g_ceph_context
  24
  25 namespace {
  26
  27 const coll_t cid;
  28
  29 ghobject_t make_ghobject(const char *oid)
  30 {
  31   return ghobject_t{hobject_t{oid, "", CEPH_NOSNAP, 0, 0, ""}};
  32 }
  33
  34 } // anonymous namespace
  35
  36 class MemStoreClone : public StoreTestFixture {
  37 public:
  38   MemStoreClone()
  39     : StoreTestFixture("memstore")
  40   {}
  41   void SetUp() override {
  42     StoreTestFixture::SetUp();
  43     if (HasFailure()) {
  44       return;
  45     }
  46     ObjectStore::Transaction t;
  47     t.create_collection(cid, 4);
  48     unsigned r = store->apply_transaction(nullptr, std::move(t));
  49     if (r != 0) {
  50       derr << "failed to create collection with " << cpp_strerror(r) << dendl;
  51     }
  52     ASSERT_EQ(0U, r);
  53   }
  54 };
  55
  56 // src 11[11 11 11 11]11
  57 // dst 22 22 22 22 22 22
  58 // res 22 11 11 11 11 22
  59 TEST_F(MemStoreClone, CloneRangeAllocated)
  60 {
  61   ASSERT_TRUE(store);
  62
  63   const auto src = make_ghobject("src1");
  64   const auto dst = make_ghobject("dst1");
  65
  66   bufferlist srcbl, dstbl, result, expected;
  67   srcbl.append("111111111111");
  68   dstbl.append("222222222222");
  69   expected.append("221111111122");
  70
  71   ObjectStore::Transaction t;
  72   t.write(cid, src, 0, 12, srcbl);
  73   t.write(cid, dst, 0, 12, dstbl);
  74   t.clone_range(cid, src, dst, 2, 8, 2);
  75   ASSERT_EQ(0u, store->apply_transaction(nullptr, std::move(t)));
  76   ASSERT_EQ(12, store->read(cid, dst, 0, 12, result));
  77   ASSERT_EQ(expected, result);
  78 }
  79
  80 // src __[__ __ __ __]__ 11 11
  81 // dst 22 22 22 22 22 22
  82 // res 22 00 00 00 00 22
  83 TEST_F(MemStoreClone, CloneRangeHole)
  84 {
  85   ASSERT_TRUE(store);
  86
  87   const auto src = make_ghobject("src2");
  88   const auto dst = make_ghobject("dst2");
  89
  90   bufferlist srcbl, dstbl, result, expected;
  91   srcbl.append("1111");
  92   dstbl.append("222222222222");
  93   expected.append("22\000\000\000\000\000\000\000\00022", 12);
  94
  95   ObjectStore::Transaction t;
  96   t.write(cid, src, 12, 4, srcbl);
  97   t.write(cid, dst, 0, 12, dstbl);
  98   t.clone_range(cid, src, dst, 2, 8, 2);
  99   ASSERT_EQ(0u, store->apply_transaction(nullptr, std::move(t)));
 100   ASSERT_EQ(12, store->read(cid, dst, 0, 12, result));
 101   ASSERT_EQ(expected, result);
 102 }
 103
 104 // src __[__ __ __ 11]11
 105 // dst 22 22 22 22 22 22
 106 // res 22 00 00 00 11 22
 107 TEST_F(MemStoreClone, CloneRangeHoleStart)
 108 {
 109   ASSERT_TRUE(store);
 110
 111   const auto src = make_ghobject("src3");
 112   const auto dst = make_ghobject("dst3");
 113
 114   bufferlist srcbl, dstbl, result, expected;
 115   srcbl.append("1111");
 116   dstbl.append("222222222222");
 117   expected.append("22\000\000\000\000\000\0001122", 12);
 118
 119   ObjectStore::Transaction t;
 120   t.write(cid, src, 8, 4, srcbl);
 121   t.write(cid, dst, 0, 12, dstbl);
 122   t.clone_range(cid, src, dst, 2, 8, 2);
 123   ASSERT_EQ(0u, store->apply_transaction(nullptr, std::move(t)));
 124   ASSERT_EQ(12, store->read(cid, dst, 0, 12, result));
 125   ASSERT_EQ(expected, result);
 126 }
 127
 128 // src 11[11 __ __ 11]11
 129 // dst 22 22 22 22 22 22
 130 // res 22 11 00 00 11 22
 131 TEST_F(MemStoreClone, CloneRangeHoleMiddle)
 132 {
 133   ASSERT_TRUE(store);
 134
 135   const auto src = make_ghobject("src4");
 136   const auto dst = make_ghobject("dst4");
 137
 138   bufferlist srcbl, dstbl, result, expected;
 139   srcbl.append("1111");
 140   dstbl.append("222222222222");
 141   expected.append("2211\000\000\000\0001122", 12);
 142
 143   ObjectStore::Transaction t;
 144   t.write(cid, src, 0, 4, srcbl);
 145   t.write(cid, src, 8, 4, srcbl);
 146   t.write(cid, dst, 0, 12, dstbl);
 147   t.clone_range(cid, src, dst, 2, 8, 2);
 148   ASSERT_EQ(0u, store->apply_transaction(nullptr, std::move(t)));
 149   ASSERT_EQ(12, store->read(cid, dst, 0, 12, result));
 150   ASSERT_EQ(expected, result);
 151 }
 152
 153 // src 11[11 __ __ __]__ 11 11
 154 // dst 22 22 22 22 22 22
 155 // res 22 11 00 00 00 22
 156 TEST_F(MemStoreClone, CloneRangeHoleEnd)
 157 {
 158   ASSERT_TRUE(store);
 159
 160   const auto src = make_ghobject("src5");
 161   const auto dst = make_ghobject("dst5");
 162
 163   bufferlist srcbl, dstbl, result, expected;
 164   srcbl.append("1111");
 165   dstbl.append("222222222222");
 166   expected.append("2211\000\000\000\000\000\00022", 12);
 167
 168   ObjectStore::Transaction t;
 169   t.write(cid, src, 0, 4, srcbl);
 170   t.write(cid, src, 12, 4, srcbl);
 171   t.write(cid, dst, 0, 12, dstbl);
 172   t.clone_range(cid, src, dst, 2, 8, 2);
 173   ASSERT_EQ(0u, store->apply_transaction(nullptr, std::move(t)));
 174   ASSERT_EQ(12, store->read(cid, dst, 0, 12, result));
 175   ASSERT_EQ(expected, result);
 176 }
 177
 178 int main(int argc, char** argv)
 179 {
 180   // default to memstore
 181   vector<const char*> defaults{
 182     "--osd_objectstore", "memstore",
 183     "--osd_data", "msc.test_temp_dir",
 184     "--memstore_page_size", "4",
 185   };
 186
 187   vector<const char*> args;
 188   argv_to_vec(argc, (const char **)argv, args);
 189
 190   auto cct = global_init(&defaults, args, CEPH_ENTITY_TYPE_CLIENT,
 191                          CODE_ENVIRONMENT_UTILITY, 0);
 192   common_init_finish(g_ceph_context);
 193
 194   ::testing::InitGoogleTest(&argc, argv);
 195   return RUN_ALL_TESTS();
 196 }