ceph/src/test/librados/snapshots.cc

   1 #include "include/rados.h"
   2 #include "test/librados/test.h"
   3 #include "test/librados/TestCase.h"
   4
   5 #include <algorithm>
   6 #include <errno.h>
   7 #include "gtest/gtest.h"
   8 #include <string>
   9
  10 using std::string;
  11
  12 typedef RadosTest LibRadosSnapshots;
  13 typedef RadosTest LibRadosSnapshotsSelfManaged;
  14 typedef RadosTestEC LibRadosSnapshotsEC;
  15 typedef RadosTestEC LibRadosSnapshotsSelfManagedEC;
  16
  17 const int bufsize = 128;
  18
  19 TEST_F(LibRadosSnapshots, SnapList) {
  20   char buf[bufsize];
  21   memset(buf, 0xcc, sizeof(buf));
  22   ASSERT_EQ(0, rados_write(ioctx, "foo", buf, sizeof(buf), 0));
  23   ASSERT_EQ(0, rados_ioctx_snap_create(ioctx, "snap1"));
  24   rados_snap_t snaps[10];
  25   EXPECT_EQ(1, rados_ioctx_snap_list(ioctx, snaps,
  26                                      sizeof(snaps) / sizeof(snaps[0])));
  27   rados_snap_t rid;
  28   EXPECT_EQ(0, rados_ioctx_snap_lookup(ioctx, "snap1", &rid));
  29   EXPECT_EQ(rid, snaps[0]);
  30   EXPECT_EQ(0, rados_ioctx_snap_remove(ioctx, "snap1"));
  31 }
  32
  33 TEST_F(LibRadosSnapshots, SnapRemove) {
  34   char buf[bufsize];
  35   memset(buf, 0xcc, sizeof(buf));
  36   ASSERT_EQ(0, rados_write(ioctx, "foo", buf, sizeof(buf), 0));
  37   ASSERT_EQ(0, rados_ioctx_snap_create(ioctx, "snap1"));
  38   rados_snap_t rid;
  39   ASSERT_EQ(0, rados_ioctx_snap_lookup(ioctx, "snap1", &rid));
  40   ASSERT_EQ(-EEXIST, rados_ioctx_snap_create(ioctx, "snap1"));
  41   ASSERT_EQ(0, rados_ioctx_snap_remove(ioctx, "snap1"));
  42   ASSERT_EQ(-ENOENT, rados_ioctx_snap_lookup(ioctx, "snap1", &rid));
  43 }
  44
  45 TEST_F(LibRadosSnapshots, Rollback) {
  46   char buf[bufsize];
  47   memset(buf, 0xcc, sizeof(buf));
  48   ASSERT_EQ(0, rados_write(ioctx, "foo", buf, sizeof(buf), 0));
  49   ASSERT_EQ(0, rados_ioctx_snap_create(ioctx, "snap1"));
  50   char buf2[sizeof(buf)];
  51   memset(buf2, 0xdd, sizeof(buf2));
  52   EXPECT_EQ(0, rados_write_full(ioctx, "foo", buf2, sizeof(buf2)));
  53   EXPECT_EQ(0, rados_ioctx_snap_rollback(ioctx, "foo", "snap1"));
  54   char buf3[sizeof(buf)];
  55   EXPECT_EQ((int)sizeof(buf3), rados_read(ioctx, "foo", buf3, sizeof(buf3), 0));
  56   EXPECT_EQ(0, memcmp(buf, buf3, sizeof(buf)));
  57   EXPECT_EQ(0, rados_ioctx_snap_remove(ioctx, "snap1"));
  58 }
  59
  60 TEST_F(LibRadosSnapshots, SnapGetName) {
  61   char buf[bufsize];
  62   memset(buf, 0xcc, sizeof(buf));
  63   ASSERT_EQ(0, rados_write(ioctx, "foo", buf, sizeof(buf), 0));
  64   ASSERT_EQ(0, rados_ioctx_snap_create(ioctx, "snapfoo"));
  65   rados_snap_t rid;
  66   EXPECT_EQ(0, rados_ioctx_snap_lookup(ioctx, "snapfoo", &rid));
  67   EXPECT_EQ(-ENOENT, rados_ioctx_snap_lookup(ioctx, "snapbar", &rid));
  68   char name[128];
  69   memset(name, 0, sizeof(name));
  70   EXPECT_EQ(0, rados_ioctx_snap_get_name(ioctx, rid, name, sizeof(name)));
  71   time_t snaptime;
  72   EXPECT_EQ(0, rados_ioctx_snap_get_stamp(ioctx, rid, &snaptime));
  73   EXPECT_EQ(0, strcmp(name, "snapfoo"));
  74   EXPECT_EQ(0, rados_ioctx_snap_remove(ioctx, "snapfoo"));
  75 }
  76
  77 TEST_F(LibRadosSnapshotsSelfManaged, Snap) {
  78   std::vector<uint64_t> my_snaps;
  79   my_snaps.push_back(-2);
  80   ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_create(ioctx, &my_snaps.back()));
  81   ::std::reverse(my_snaps.begin(), my_snaps.end());
  82   ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_set_write_ctx(ioctx, my_snaps[0],
  83                                         &my_snaps[0], my_snaps.size()));
  84   ::std::reverse(my_snaps.begin(), my_snaps.end());
  85   char buf[bufsize];
  86   memset(buf, 0xcc, sizeof(buf));
  87   ASSERT_EQ(0, rados_write(ioctx, "foo", buf, sizeof(buf), 0));
  88
  89   my_snaps.push_back(-2);
  90   rados_completion_t completion;
  91   ASSERT_EQ(0, rados_aio_create_completion2(nullptr, nullptr,
  92                                            &completion));
  93   rados_aio_ioctx_selfmanaged_snap_create(ioctx, &my_snaps.back(), completion);
  94   ASSERT_EQ(0, rados_aio_wait_for_complete(completion));
  95   rados_aio_release(completion);
  96   ::std::reverse(my_snaps.begin(), my_snaps.end());
  97   ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_set_write_ctx(ioctx, my_snaps[0],
  98                                         &my_snaps[0], my_snaps.size()));
  99   ::std::reverse(my_snaps.begin(), my_snaps.end());
 100   char buf2[sizeof(buf)];
 101   memset(buf2, 0xdd, sizeof(buf2));
 102   ASSERT_EQ(0, rados_write(ioctx, "foo", buf2, sizeof(buf2), 0));
 103   rados_ioctx_snap_set_read(ioctx, my_snaps[1]-1);
 104   char buf3[sizeof(buf)];
 105   ASSERT_EQ(-ENOENT, rados_read(ioctx, "foo", buf3, sizeof(buf3), 0));
 106
 107   rados_ioctx_snap_set_read(ioctx, my_snaps[1]);
 108   ASSERT_EQ((int)sizeof(buf3), rados_read(ioctx, "foo", buf3, sizeof(buf3), 0));
 109   ASSERT_EQ(0, memcmp(buf3, buf, sizeof(buf)));
 110
 111   ASSERT_EQ(0, rados_aio_create_completion2(nullptr, nullptr,
 112                                            &completion));
 113   rados_aio_ioctx_selfmanaged_snap_remove(ioctx, my_snaps.back(), completion);
 114   ASSERT_EQ(0, rados_aio_wait_for_complete(completion));
 115   rados_aio_release(completion);
 116   my_snaps.pop_back();
 117   ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_remove(ioctx, my_snaps.back()));
 118   my_snaps.pop_back();
 119   rados_ioctx_snap_set_read(ioctx, LIBRADOS_SNAP_HEAD);
 120   ASSERT_EQ(0, rados_remove(ioctx, "foo"));
 121 }
 122
 123 TEST_F(LibRadosSnapshotsSelfManaged, Rollback) {
 124   std::vector<uint64_t> my_snaps;
 125   my_snaps.push_back(-2);
 126   ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_create(ioctx, &my_snaps.back()));
 127   ::std::reverse(my_snaps.begin(), my_snaps.end());
 128   ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_set_write_ctx(ioctx, my_snaps[0],
 129                                         &my_snaps[0], my_snaps.size()));
 130   ::std::reverse(my_snaps.begin(), my_snaps.end());
 131   char buf[bufsize];
 132   memset(buf, 0xcc, sizeof(buf));
 133   ASSERT_EQ(0, rados_write(ioctx, "foo", buf, sizeof(buf), 0));
 134
 135   my_snaps.push_back(-2);
 136   ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_create(ioctx, &my_snaps.back()));
 137   ::std::reverse(my_snaps.begin(), my_snaps.end());
 138   ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_set_write_ctx(ioctx, my_snaps[0],
 139                                         &my_snaps[0], my_snaps.size()));
 140   ::std::reverse(my_snaps.begin(), my_snaps.end());
 141   char buf2[sizeof(buf)];
 142   memset(buf2, 0xdd, sizeof(buf2));
 143   ASSERT_EQ(0, rados_write(ioctx, "foo", buf2, sizeof(buf2), 0));
 144   rados_ioctx_selfmanaged_snap_rollback(ioctx, "foo", my_snaps[1]);
 145   char buf3[sizeof(buf)];
 146   ASSERT_EQ((int)sizeof(buf3), rados_read(ioctx, "foo", buf3, sizeof(buf3), 0));
 147   ASSERT_EQ(0, memcmp(buf3, buf, sizeof(buf)));
 148
 149   ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_remove(ioctx, my_snaps.back()));
 150   my_snaps.pop_back();
 151   ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_remove(ioctx, my_snaps.back()));
 152   my_snaps.pop_back();
 153   ASSERT_EQ(0, rados_remove(ioctx, "foo"));
 154 }
 155
 156 // EC testing
 157 TEST_F(LibRadosSnapshotsEC, SnapList) {
 158   char buf[bufsize];
 159   memset(buf, 0xcc, sizeof(buf));
 160   ASSERT_EQ(0, rados_write(ioctx, "foo", buf, sizeof(buf), 0));
 161   ASSERT_EQ(0, rados_ioctx_snap_create(ioctx, "snap1"));
 162   rados_snap_t snaps[10];
 163   EXPECT_EQ(1, rados_ioctx_snap_list(ioctx, snaps,
 164                                      sizeof(snaps) / sizeof(snaps[0])));
 165   rados_snap_t rid;
 166   EXPECT_EQ(0, rados_ioctx_snap_lookup(ioctx, "snap1", &rid));
 167   EXPECT_EQ(rid, snaps[0]);
 168   EXPECT_EQ(0, rados_ioctx_snap_remove(ioctx, "snap1"));
 169 }
 170
 171 TEST_F(LibRadosSnapshotsEC, SnapRemove) {
 172   char buf[bufsize];
 173   memset(buf, 0xcc, sizeof(buf));
 174   ASSERT_EQ(0, rados_write(ioctx, "foo", buf, sizeof(buf), 0));
 175   ASSERT_EQ(0, rados_ioctx_snap_create(ioctx, "snap1"));
 176   rados_snap_t rid;
 177   ASSERT_EQ(0, rados_ioctx_snap_lookup(ioctx, "snap1", &rid));
 178   ASSERT_EQ(-EEXIST, rados_ioctx_snap_create(ioctx, "snap1"));
 179   ASSERT_EQ(0, rados_ioctx_snap_remove(ioctx, "snap1"));
 180   ASSERT_EQ(-ENOENT, rados_ioctx_snap_lookup(ioctx, "snap1", &rid));
 181 }
 182
 183 TEST_F(LibRadosSnapshotsEC, Rollback) {
 184   char buf[bufsize];
 185   memset(buf, 0xcc, sizeof(buf));
 186   ASSERT_EQ(0, rados_write(ioctx, "foo", buf, sizeof(buf), 0));
 187   ASSERT_EQ(0, rados_ioctx_snap_create(ioctx, "snap1"));
 188   char buf2[sizeof(buf)];
 189   memset(buf2, 0xdd, sizeof(buf2));
 190   EXPECT_EQ(0, rados_write_full(ioctx, "foo", buf2, sizeof(buf2)));
 191   EXPECT_EQ(0, rados_ioctx_snap_rollback(ioctx, "foo", "snap1"));
 192   char buf3[sizeof(buf)];
 193   EXPECT_EQ((int)sizeof(buf3), rados_read(ioctx, "foo", buf3, sizeof(buf3), 0));
 194   EXPECT_EQ(0, memcmp(buf, buf3, sizeof(buf)));
 195   EXPECT_EQ(0, rados_ioctx_snap_remove(ioctx, "snap1"));
 196 }
 197
 198 TEST_F(LibRadosSnapshotsEC, SnapGetName) {
 199   char buf[bufsize];
 200   memset(buf, 0xcc, sizeof(buf));
 201   ASSERT_EQ(0, rados_write(ioctx, "foo", buf, sizeof(buf), 0));
 202   ASSERT_EQ(0, rados_ioctx_snap_create(ioctx, "snapfoo"));
 203   rados_snap_t rid;
 204   EXPECT_EQ(0, rados_ioctx_snap_lookup(ioctx, "snapfoo", &rid));
 205   EXPECT_EQ(-ENOENT, rados_ioctx_snap_lookup(ioctx, "snapbar", &rid));
 206   char name[128];
 207   memset(name, 0, sizeof(name));
 208   EXPECT_EQ(0, rados_ioctx_snap_get_name(ioctx, rid, name, sizeof(name)));
 209   time_t snaptime;
 210   EXPECT_EQ(0, rados_ioctx_snap_get_stamp(ioctx, rid, &snaptime));
 211   EXPECT_EQ(0, strcmp(name, "snapfoo"));
 212   EXPECT_EQ(0, rados_ioctx_snap_remove(ioctx, "snapfoo"));
 213 }
 214
 215 TEST_F(LibRadosSnapshotsSelfManagedEC, Snap) {
 216   std::vector<uint64_t> my_snaps;
 217   my_snaps.push_back(-2);
 218   ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_create(ioctx, &my_snaps.back()));
 219   ::std::reverse(my_snaps.begin(), my_snaps.end());
 220   ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_set_write_ctx(ioctx, my_snaps[0],
 221                                         &my_snaps[0], my_snaps.size()));
 222   ::std::reverse(my_snaps.begin(), my_snaps.end());
 223   int bsize = alignment;
 224   char *buf = (char *)new char[bsize];
 225   memset(buf, 0xcc, bsize);
 226   ASSERT_EQ(0, rados_write(ioctx, "foo", buf, bsize, 0));
 227
 228   my_snaps.push_back(-2);
 229   rados_completion_t completion;
 230   ASSERT_EQ(0, rados_aio_create_completion2(nullptr, nullptr,
 231                                            &completion));
 232   rados_aio_ioctx_selfmanaged_snap_create(ioctx, &my_snaps.back(), completion);
 233   ASSERT_EQ(0, rados_aio_wait_for_complete(completion));
 234   rados_aio_release(completion);
 235   ::std::reverse(my_snaps.begin(), my_snaps.end());
 236   ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_set_write_ctx(ioctx, my_snaps[0],
 237                                         &my_snaps[0], my_snaps.size()));
 238   ::std::reverse(my_snaps.begin(), my_snaps.end());
 239   char *buf2 = (char *)new char[bsize];
 240   memset(buf2, 0xdd, bsize);
 241   ASSERT_EQ(0, rados_write(ioctx, "foo", buf2, bsize, bsize));
 242   rados_ioctx_snap_set_read(ioctx, my_snaps[1]-1);
 243   char *buf3 = (char *)new char[bsize*2];
 244   ASSERT_EQ(-ENOENT, rados_read(ioctx, "foo", buf3, bsize*2, 0));
 245
 246   rados_ioctx_snap_set_read(ioctx, my_snaps[1]);
 247   ASSERT_EQ(bsize, rados_read(ioctx, "foo", buf3, bsize*2, 0));
 248   ASSERT_EQ(0, memcmp(buf3, buf, bsize));
 249
 250   ASSERT_EQ(0, rados_aio_create_completion2(nullptr, nullptr,
 251                                            &completion));
 252   rados_aio_ioctx_selfmanaged_snap_remove(ioctx, my_snaps.back(), completion);
 253   ASSERT_EQ(0, rados_aio_wait_for_complete(completion));
 254   rados_aio_release(completion);
 255   my_snaps.pop_back();
 256   ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_remove(ioctx, my_snaps.back()));
 257   my_snaps.pop_back();
 258   rados_ioctx_snap_set_read(ioctx, LIBRADOS_SNAP_HEAD);
 259   ASSERT_EQ(0, rados_remove(ioctx, "foo"));
 260   delete[] buf;
 261   delete[] buf2;
 262   delete[] buf3;
 263 }
 264
 265 TEST_F(LibRadosSnapshotsSelfManagedEC, Rollback) {
 266   std::vector<uint64_t> my_snaps;
 267   my_snaps.push_back(-2);
 268   ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_create(ioctx, &my_snaps.back()));
 269   ::std::reverse(my_snaps.begin(), my_snaps.end());
 270   ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_set_write_ctx(ioctx, my_snaps[0],
 271                                         &my_snaps[0], my_snaps.size()));
 272   ::std::reverse(my_snaps.begin(), my_snaps.end());
 273   int bsize = alignment;
 274   char *buf = (char *)new char[bsize];
 275   memset(buf, 0xcc, bsize);
 276   ASSERT_EQ(0, rados_write(ioctx, "foo", buf, bsize, 0));
 277
 278   my_snaps.push_back(-2);
 279   ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_create(ioctx, &my_snaps.back()));
 280   ::std::reverse(my_snaps.begin(), my_snaps.end());
 281   ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_set_write_ctx(ioctx, my_snaps[0],
 282                                         &my_snaps[0], my_snaps.size()));
 283   ::std::reverse(my_snaps.begin(), my_snaps.end());
 284   char *buf2 = (char *)new char[bsize];
 285   memset(buf2, 0xdd, bsize);
 286
 287   ASSERT_EQ(0, rados_write(ioctx, "foo", buf2, bsize, bsize));
 288   rados_ioctx_selfmanaged_snap_rollback(ioctx, "foo", my_snaps[1]);
 289   char *buf3 = (char *)new char[bsize*2];
 290   ASSERT_EQ(bsize, rados_read(ioctx, "foo", buf3, bsize*2, 0));
 291   ASSERT_EQ(0, memcmp(buf3, buf, bsize));
 292
 293   ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_remove(ioctx, my_snaps.back()));
 294   my_snaps.pop_back();
 295   ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_remove(ioctx, my_snaps.back()));
 296   my_snaps.pop_back();
 297   ASSERT_EQ(0, rados_remove(ioctx, "foo"));
 298   delete[] buf;
 299   delete[] buf2;
 300   delete[] buf3;
 301 }