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/ceph_assert.h"
  20 #include "common/errno.h"
  21 #include "store_test_fixture.h"
  22
  23 #define dout_context g_ceph_context
  24
  25 using namespace std;
  26
  27 namespace {
  28
  29 const coll_t cid;
  30
  31 ghobject_t make_ghobject(const char *oid)
  32 {
  33   return ghobject_t{hobject_t{oid, "", CEPH_NOSNAP, 0, 0, ""}};
  34 }
  35
  36 } // anonymous namespace
  37
  38 class MemStoreClone : public StoreTestFixture {
  39 public:
  40   MemStoreClone()
  41     : StoreTestFixture("memstore")
  42   {}
  43   void SetUp() override {
  44     StoreTestFixture::SetUp();
  45     if (HasFailure()) {
  46       return;
  47     }
  48     ObjectStore::Transaction t;
  49     ch = store->create_new_collection(cid);
  50     t.create_collection(cid, 4);
  51     unsigned r = store->queue_transaction(ch, std::move(t));
  52     if (r != 0) {
  53       derr << "failed to create collection with " << cpp_strerror(r) << dendl;
  54     }
  55     ASSERT_EQ(0U, r);
  56   }
  57   void TearDown() override {
  58     ch.reset();
  59     StoreTestFixture::TearDown();
  60   }
  61 };
  62
  63 // src 11[11 11 11 11]11
  64 // dst 22 22 22 22 22 22
  65 // res 22 11 11 11 11 22
  66 TEST_F(MemStoreClone, CloneRangeAllocated)
  67 {
  68   ASSERT_TRUE(store);
  69
  70   const auto src = make_ghobject("src1");
  71   const auto dst = make_ghobject("dst1");
  72
  73   bufferlist srcbl, dstbl, result, expected;
  74   srcbl.append("111111111111");
  75   dstbl.append("222222222222");
  76   expected.append("221111111122");
  77
  78   ObjectStore::Transaction t;
  79   t.write(cid, src, 0, 12, srcbl);
  80   t.write(cid, dst, 0, 12, dstbl);
  81   t.clone_range(cid, src, dst, 2, 8, 2);
  82   ASSERT_EQ(0, store->queue_transaction(ch, std::move(t)));
  83   ASSERT_EQ(12, store->read(ch, dst, 0, 12, result));
  84   ASSERT_EQ(expected, result);
  85 }
  86
  87 // src __[__ __ __ __]__ 11 11
  88 // dst 22 22 22 22 22 22
  89 // res 22 00 00 00 00 22
  90 TEST_F(MemStoreClone, CloneRangeHole)
  91 {
  92   ASSERT_TRUE(store);
  93
  94   const auto src = make_ghobject("src2");
  95   const auto dst = make_ghobject("dst2");
  96
  97   bufferlist srcbl, dstbl, result, expected;
  98   srcbl.append("1111");
  99   dstbl.append("222222222222");
 100   expected.append("22\000\000\000\000\000\000\000\00022", 12);
 101
 102   ObjectStore::Transaction t;
 103   t.write(cid, src, 12, 4, srcbl);
 104   t.write(cid, dst, 0, 12, dstbl);
 105   t.clone_range(cid, src, dst, 2, 8, 2);
 106   ASSERT_EQ(0, store->queue_transaction(ch, std::move(t)));
 107   ASSERT_EQ(12, store->read(ch, dst, 0, 12, result));
 108   ASSERT_EQ(expected, result);
 109 }
 110
 111 // src __[__ __ __ 11]11
 112 // dst 22 22 22 22 22 22
 113 // res 22 00 00 00 11 22
 114 TEST_F(MemStoreClone, CloneRangeHoleStart)
 115 {
 116   ASSERT_TRUE(store);
 117
 118   const auto src = make_ghobject("src3");
 119   const auto dst = make_ghobject("dst3");
 120
 121   bufferlist srcbl, dstbl, result, expected;
 122   srcbl.append("1111");
 123   dstbl.append("222222222222");
 124   expected.append("22\000\000\000\000\000\0001122", 12);
 125
 126   ObjectStore::Transaction t;
 127   t.write(cid, src, 8, 4, srcbl);
 128   t.write(cid, dst, 0, 12, dstbl);
 129   t.clone_range(cid, src, dst, 2, 8, 2);
 130   ASSERT_EQ(0, store->queue_transaction(ch, std::move(t)));
 131   ASSERT_EQ(12, store->read(ch, dst, 0, 12, result));
 132   ASSERT_EQ(expected, result);
 133 }
 134
 135 // src 11[11 __ __ 11]11
 136 // dst 22 22 22 22 22 22
 137 // res 22 11 00 00 11 22
 138 TEST_F(MemStoreClone, CloneRangeHoleMiddle)
 139 {
 140   ASSERT_TRUE(store);
 141
 142   const auto src = make_ghobject("src4");
 143   const auto dst = make_ghobject("dst4");
 144
 145   bufferlist srcbl, dstbl, result, expected;
 146   srcbl.append("1111");
 147   dstbl.append("222222222222");
 148   expected.append("2211\000\000\000\0001122", 12);
 149
 150   ObjectStore::Transaction t;
 151   t.write(cid, src, 0, 4, srcbl);
 152   t.write(cid, src, 8, 4, srcbl);
 153   t.write(cid, dst, 0, 12, dstbl);
 154   t.clone_range(cid, src, dst, 2, 8, 2);
 155   ASSERT_EQ(0, store->queue_transaction(ch, std::move(t)));
 156   ASSERT_EQ(12, store->read(ch, dst, 0, 12, result));
 157   ASSERT_EQ(expected, result);
 158 }
 159
 160 // src 11[11 __ __ __]__ 11 11
 161 // dst 22 22 22 22 22 22
 162 // res 22 11 00 00 00 22
 163 TEST_F(MemStoreClone, CloneRangeHoleEnd)
 164 {
 165   ASSERT_TRUE(store);
 166
 167   const auto src = make_ghobject("src5");
 168   const auto dst = make_ghobject("dst5");
 169
 170   bufferlist srcbl, dstbl, result, expected;
 171   srcbl.append("1111");
 172   dstbl.append("222222222222");
 173   expected.append("2211\000\000\000\000\000\00022", 12);
 174
 175   ObjectStore::Transaction t;
 176   t.write(cid, src, 0, 4, srcbl);
 177   t.write(cid, src, 12, 4, srcbl);
 178   t.write(cid, dst, 0, 12, dstbl);
 179   t.clone_range(cid, src, dst, 2, 8, 2);
 180   ASSERT_EQ(0, store->queue_transaction(ch, std::move(t)));
 181   ASSERT_EQ(12, store->read(ch, dst, 0, 12, result));
 182   ASSERT_EQ(expected, result);
 183 }
 184
 185 int main(int argc, char** argv)
 186 {
 187   // default to memstore
 188   map<string,string> defaults = {
 189     { "osd_objectstore", "memstore" },
 190     { "osd_data", "msc.test_temp_dir" },
 191     { "memstore_page_size", "4" }
 192   };
 193
 194   auto args = argv_to_vec(argc, argv);
 195   auto cct = global_init(&defaults, args, CEPH_ENTITY_TYPE_CLIENT,
 196                          CODE_ENVIRONMENT_UTILITY,
 197                          CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
 198   common_init_finish(g_ceph_context);
 199
 200   ::testing::InitGoogleTest(&argc, argv);
 201   return RUN_ALL_TESTS();
 202 }