1 #include "include/rados/librados.hpp"
2 #include "test/librados/test.h"
3 #include "test/librados/TestCase.h"
7 #include "gtest/gtest.h"
10 using namespace librados;
13 typedef RadosTest LibRadosSnapshots;
14 typedef RadosTest LibRadosSnapshotsSelfManaged;
15 typedef RadosTestPP LibRadosSnapshotsPP;
16 typedef RadosTestPP LibRadosSnapshotsSelfManagedPP;
17 typedef RadosTestEC LibRadosSnapshotsEC;
18 typedef RadosTestEC LibRadosSnapshotsSelfManagedEC;
19 typedef RadosTestECPP LibRadosSnapshotsECPP;
20 typedef RadosTestECPP LibRadosSnapshotsSelfManagedECPP;
22 const int bufsize = 128;
24 TEST_F(LibRadosSnapshots, SnapList) {
26 memset(buf, 0xcc, sizeof(buf));
27 ASSERT_EQ(0, rados_write(ioctx, "foo", buf, sizeof(buf), 0));
28 ASSERT_EQ(0, rados_ioctx_snap_create(ioctx, "snap1"));
29 rados_snap_t snaps[10];
30 EXPECT_EQ(1, rados_ioctx_snap_list(ioctx, snaps,
31 sizeof(snaps) / sizeof(snaps[0])));
33 EXPECT_EQ(0, rados_ioctx_snap_lookup(ioctx, "snap1", &rid));
34 EXPECT_EQ(rid, snaps[0]);
35 EXPECT_EQ(0, rados_ioctx_snap_remove(ioctx, "snap1"));
38 TEST_F(LibRadosSnapshotsPP, SnapListPP) {
40 memset(buf, 0xcc, sizeof(buf));
42 bl1.append(buf, sizeof(buf));
43 ASSERT_EQ(0, ioctx.write("foo", bl1, sizeof(buf), 0));
44 ASSERT_FALSE(cluster.get_pool_is_selfmanaged_snaps_mode(pool_name));
45 ASSERT_EQ(0, ioctx.snap_create("snap1"));
46 ASSERT_FALSE(cluster.get_pool_is_selfmanaged_snaps_mode(pool_name));
47 std::vector<snap_t> snaps;
48 EXPECT_EQ(0, ioctx.snap_list(&snaps));
49 EXPECT_EQ(1U, snaps.size());
51 EXPECT_EQ(0, ioctx.snap_lookup("snap1", &rid));
52 EXPECT_EQ(rid, snaps[0]);
53 EXPECT_EQ(0, ioctx.snap_remove("snap1"));
54 ASSERT_FALSE(cluster.get_pool_is_selfmanaged_snaps_mode(pool_name));
57 TEST_F(LibRadosSnapshots, SnapRemove) {
59 memset(buf, 0xcc, sizeof(buf));
60 ASSERT_EQ(0, rados_write(ioctx, "foo", buf, sizeof(buf), 0));
61 ASSERT_EQ(0, rados_ioctx_snap_create(ioctx, "snap1"));
63 ASSERT_EQ(0, rados_ioctx_snap_lookup(ioctx, "snap1", &rid));
64 ASSERT_EQ(-EEXIST, rados_ioctx_snap_create(ioctx, "snap1"));
65 ASSERT_EQ(0, rados_ioctx_snap_remove(ioctx, "snap1"));
66 ASSERT_EQ(-ENOENT, rados_ioctx_snap_lookup(ioctx, "snap1", &rid));
69 TEST_F(LibRadosSnapshotsPP, SnapRemovePP) {
71 memset(buf, 0xcc, sizeof(buf));
73 bl1.append(buf, sizeof(buf));
74 ASSERT_EQ(0, ioctx.write("foo", bl1, sizeof(buf), 0));
75 ASSERT_EQ(0, ioctx.snap_create("snap1"));
77 ASSERT_EQ(0, ioctx.snap_lookup("snap1", &rid));
78 ASSERT_EQ(0, ioctx.snap_remove("snap1"));
79 ASSERT_EQ(-ENOENT, ioctx.snap_lookup("snap1", &rid));
82 TEST_F(LibRadosSnapshots, Rollback) {
84 memset(buf, 0xcc, sizeof(buf));
85 ASSERT_EQ(0, rados_write(ioctx, "foo", buf, sizeof(buf), 0));
86 ASSERT_EQ(0, rados_ioctx_snap_create(ioctx, "snap1"));
87 char buf2[sizeof(buf)];
88 memset(buf2, 0xdd, sizeof(buf2));
89 EXPECT_EQ(0, rados_write_full(ioctx, "foo", buf2, sizeof(buf2)));
90 EXPECT_EQ(0, rados_ioctx_snap_rollback(ioctx, "foo", "snap1"));
91 char buf3[sizeof(buf)];
92 EXPECT_EQ((int)sizeof(buf3), rados_read(ioctx, "foo", buf3, sizeof(buf3), 0));
93 EXPECT_EQ(0, memcmp(buf, buf3, sizeof(buf)));
94 EXPECT_EQ(0, rados_ioctx_snap_remove(ioctx, "snap1"));
97 TEST_F(LibRadosSnapshotsPP, RollbackPP) {
99 memset(buf, 0xcc, sizeof(buf));
101 bl1.append(buf, sizeof(buf));
102 ASSERT_EQ(0, ioctx.write("foo", bl1, sizeof(buf), 0));
103 ASSERT_EQ(0, ioctx.snap_create("snap1"));
104 char buf2[sizeof(buf)];
105 memset(buf2, 0xdd, sizeof(buf2));
107 bl2.append(buf2, sizeof(buf2));
108 EXPECT_EQ(0, ioctx.write_full("foo", bl2));
109 EXPECT_EQ(0, ioctx.snap_rollback("foo", "snap1"));
111 EXPECT_EQ((int)sizeof(buf), ioctx.read("foo", bl3, sizeof(buf), 0));
112 EXPECT_EQ(0, memcmp(buf, bl3.c_str(), sizeof(buf)));
113 EXPECT_EQ(0, ioctx.snap_remove("snap1"));
116 TEST_F(LibRadosSnapshots, SnapGetName) {
118 memset(buf, 0xcc, sizeof(buf));
119 ASSERT_EQ(0, rados_write(ioctx, "foo", buf, sizeof(buf), 0));
120 ASSERT_EQ(0, rados_ioctx_snap_create(ioctx, "snapfoo"));
122 EXPECT_EQ(0, rados_ioctx_snap_lookup(ioctx, "snapfoo", &rid));
123 EXPECT_EQ(-ENOENT, rados_ioctx_snap_lookup(ioctx, "snapbar", &rid));
125 memset(name, 0, sizeof(name));
126 EXPECT_EQ(0, rados_ioctx_snap_get_name(ioctx, rid, name, sizeof(name)));
128 EXPECT_EQ(0, rados_ioctx_snap_get_stamp(ioctx, rid, &snaptime));
129 EXPECT_EQ(0, strcmp(name, "snapfoo"));
130 EXPECT_EQ(0, rados_ioctx_snap_remove(ioctx, "snapfoo"));
133 TEST_F(LibRadosSnapshotsPP, SnapGetNamePP) {
135 memset(buf, 0xcc, sizeof(buf));
137 bl.append(buf, sizeof(buf));
138 ASSERT_EQ(0, ioctx.write("foo", bl, sizeof(buf), 0));
139 ASSERT_EQ(0, ioctx.snap_create("snapfoo"));
141 EXPECT_EQ(0, ioctx.snap_lookup("snapfoo", &rid));
142 EXPECT_EQ(-ENOENT, ioctx.snap_lookup("snapbar", &rid));
144 EXPECT_EQ(0, ioctx.snap_get_name(rid, &name));
146 EXPECT_EQ(0, ioctx.snap_get_stamp(rid, &snaptime));
147 EXPECT_EQ(0, strcmp(name.c_str(), "snapfoo"));
148 EXPECT_EQ(0, ioctx.snap_remove("snapfoo"));
151 TEST_F(LibRadosSnapshotsPP, SnapCreateRemovePP) {
152 // reproduces http://tracker.ceph.com/issues/10262
155 ASSERT_EQ(0, ioctx.write("foo", bl, bl.length(), 0));
156 ASSERT_EQ(0, ioctx.snap_create("snapfoo"));
157 ASSERT_EQ(0, ioctx.remove("foo"));
158 ASSERT_EQ(0, ioctx.snap_create("snapbar"));
160 std::unique_ptr<librados::ObjectWriteOperation> op(new librados::ObjectWriteOperation());
163 ASSERT_EQ(0, ioctx.operate("foo", op.get()));
165 EXPECT_EQ(0, ioctx.snap_remove("snapfoo"));
166 EXPECT_EQ(0, ioctx.snap_remove("snapbar"));
169 TEST_F(LibRadosSnapshotsSelfManaged, Snap) {
170 std::vector<uint64_t> my_snaps;
171 my_snaps.push_back(-2);
172 ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_create(ioctx, &my_snaps.back()));
173 ::std::reverse(my_snaps.begin(), my_snaps.end());
174 ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_set_write_ctx(ioctx, my_snaps[0],
175 &my_snaps[0], my_snaps.size()));
176 ::std::reverse(my_snaps.begin(), my_snaps.end());
178 memset(buf, 0xcc, sizeof(buf));
179 ASSERT_EQ(0, rados_write(ioctx, "foo", buf, sizeof(buf), 0));
181 my_snaps.push_back(-2);
182 rados_completion_t completion;
183 ASSERT_EQ(0, rados_aio_create_completion(nullptr, nullptr, nullptr,
185 rados_aio_ioctx_selfmanaged_snap_create(ioctx, &my_snaps.back(), completion);
186 ASSERT_EQ(0, rados_aio_wait_for_complete(completion));
187 rados_aio_release(completion);
188 ::std::reverse(my_snaps.begin(), my_snaps.end());
189 ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_set_write_ctx(ioctx, my_snaps[0],
190 &my_snaps[0], my_snaps.size()));
191 ::std::reverse(my_snaps.begin(), my_snaps.end());
192 char buf2[sizeof(buf)];
193 memset(buf2, 0xdd, sizeof(buf2));
194 ASSERT_EQ(0, rados_write(ioctx, "foo", buf2, sizeof(buf2), 0));
195 rados_ioctx_snap_set_read(ioctx, my_snaps[1]-1);
196 char buf3[sizeof(buf)];
197 ASSERT_EQ(-ENOENT, rados_read(ioctx, "foo", buf3, sizeof(buf3), 0));
199 rados_ioctx_snap_set_read(ioctx, my_snaps[1]);
200 ASSERT_EQ((int)sizeof(buf3), rados_read(ioctx, "foo", buf3, sizeof(buf3), 0));
201 ASSERT_EQ(0, memcmp(buf3, buf, sizeof(buf)));
203 ASSERT_EQ(0, rados_aio_create_completion(nullptr, nullptr, nullptr,
205 rados_aio_ioctx_selfmanaged_snap_remove(ioctx, my_snaps.back(), completion);
206 ASSERT_EQ(0, rados_aio_wait_for_complete(completion));
207 rados_aio_release(completion);
209 ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_remove(ioctx, my_snaps.back()));
211 rados_ioctx_snap_set_read(ioctx, LIBRADOS_SNAP_HEAD);
212 ASSERT_EQ(0, rados_remove(ioctx, "foo"));
215 TEST_F(LibRadosSnapshotsSelfManaged, Rollback) {
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());
224 memset(buf, 0xcc, sizeof(buf));
225 ASSERT_EQ(0, rados_write(ioctx, "foo", buf, sizeof(buf), 0));
227 my_snaps.push_back(-2);
228 ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_create(ioctx, &my_snaps.back()));
229 ::std::reverse(my_snaps.begin(), my_snaps.end());
230 ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_set_write_ctx(ioctx, my_snaps[0],
231 &my_snaps[0], my_snaps.size()));
232 ::std::reverse(my_snaps.begin(), my_snaps.end());
233 char buf2[sizeof(buf)];
234 memset(buf2, 0xdd, sizeof(buf2));
235 ASSERT_EQ(0, rados_write(ioctx, "foo", buf2, sizeof(buf2), 0));
236 rados_ioctx_selfmanaged_snap_rollback(ioctx, "foo", my_snaps[1]);
237 char buf3[sizeof(buf)];
238 ASSERT_EQ((int)sizeof(buf3), rados_read(ioctx, "foo", buf3, sizeof(buf3), 0));
239 ASSERT_EQ(0, memcmp(buf3, buf, sizeof(buf)));
241 ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_remove(ioctx, my_snaps.back()));
243 ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_remove(ioctx, my_snaps.back()));
245 ASSERT_EQ(0, rados_remove(ioctx, "foo"));
248 TEST_F(LibRadosSnapshotsSelfManagedPP, SnapPP) {
249 std::vector<uint64_t> my_snaps;
250 my_snaps.push_back(-2);
251 ASSERT_FALSE(cluster.get_pool_is_selfmanaged_snaps_mode(pool_name));
252 ASSERT_EQ(0, ioctx.selfmanaged_snap_create(&my_snaps.back()));
253 ASSERT_TRUE(cluster.get_pool_is_selfmanaged_snaps_mode(pool_name));
254 ::std::reverse(my_snaps.begin(), my_snaps.end());
255 ASSERT_EQ(0, ioctx.selfmanaged_snap_set_write_ctx(my_snaps[0], my_snaps));
256 ::std::reverse(my_snaps.begin(), my_snaps.end());
258 memset(buf, 0xcc, sizeof(buf));
260 bl1.append(buf, sizeof(buf));
261 ASSERT_EQ(0, ioctx.write("foo", bl1, sizeof(buf), 0));
263 my_snaps.push_back(-2);
264 librados::AioCompletion *completion = cluster.aio_create_completion();
265 ioctx.aio_selfmanaged_snap_create(&my_snaps.back(), completion);
266 ASSERT_EQ(0, completion->wait_for_complete());
267 completion->release();
268 ::std::reverse(my_snaps.begin(), my_snaps.end());
269 ASSERT_EQ(0, ioctx.selfmanaged_snap_set_write_ctx(my_snaps[0], my_snaps));
270 ::std::reverse(my_snaps.begin(), my_snaps.end());
271 char buf2[sizeof(buf)];
272 memset(buf2, 0xdd, sizeof(buf2));
274 bl2.append(buf2, sizeof(buf2));
275 ASSERT_EQ(0, ioctx.write("foo", bl2, sizeof(buf2), 0));
277 ioctx.snap_set_read(my_snaps[1]);
279 ASSERT_EQ((int)sizeof(buf), ioctx.read("foo", bl3, sizeof(buf), 0));
280 ASSERT_EQ(0, memcmp(bl3.c_str(), buf, sizeof(buf)));
282 completion = cluster.aio_create_completion();
283 ioctx.aio_selfmanaged_snap_remove(my_snaps.back(), completion);
284 ASSERT_EQ(0, completion->wait_for_complete());
285 completion->release();
287 ASSERT_EQ(0, ioctx.selfmanaged_snap_remove(my_snaps.back()));
289 ioctx.snap_set_read(LIBRADOS_SNAP_HEAD);
290 ASSERT_TRUE(cluster.get_pool_is_selfmanaged_snaps_mode(pool_name));
291 ASSERT_EQ(0, ioctx.remove("foo"));
294 TEST_F(LibRadosSnapshotsSelfManagedPP, RollbackPP) {
295 std::vector<uint64_t> my_snaps;
297 ASSERT_EQ(0, cluster.ioctx_create(pool_name.c_str(), readioctx));
298 readioctx.set_namespace(nspace);
299 readioctx.snap_set_read(LIBRADOS_SNAP_DIR);
301 my_snaps.push_back(-2);
302 ASSERT_EQ(0, ioctx.selfmanaged_snap_create(&my_snaps.back()));
303 ::std::reverse(my_snaps.begin(), my_snaps.end());
304 ASSERT_EQ(0, ioctx.selfmanaged_snap_set_write_ctx(my_snaps[0], my_snaps));
305 ::std::reverse(my_snaps.begin(), my_snaps.end());
307 memset(buf, 0xcc, sizeof(buf));
309 bl1.append(buf, sizeof(buf));
310 //Write 3 consecutive buffers
311 ASSERT_EQ(0, ioctx.write("foo", bl1, sizeof(buf), 0));
312 ASSERT_EQ(0, ioctx.write("foo", bl1, sizeof(buf), bufsize));
313 ASSERT_EQ(0, ioctx.write("foo", bl1, sizeof(buf), bufsize*2));
317 snap_t head = SNAP_HEAD;
318 ASSERT_EQ(0, readioctx.list_snaps("foo", &ss));
319 ASSERT_EQ(1u, ss.clones.size());
320 ASSERT_EQ(head, ss.clones[0].cloneid);
321 ASSERT_EQ(0u, ss.clones[0].snaps.size());
322 ASSERT_EQ(0u, ss.clones[0].overlap.size());
323 ASSERT_EQ(384u, ss.clones[0].size);
325 my_snaps.push_back(-2);
326 ASSERT_EQ(0, ioctx.selfmanaged_snap_create(&my_snaps.back()));
327 ::std::reverse(my_snaps.begin(), my_snaps.end());
328 ASSERT_EQ(0, ioctx.selfmanaged_snap_set_write_ctx(my_snaps[0], my_snaps));
329 ::std::reverse(my_snaps.begin(), my_snaps.end());
330 char buf2[sizeof(buf)];
331 memset(buf2, 0xdd, sizeof(buf2));
333 bl2.append(buf2, sizeof(buf2));
334 //Change the middle buffer
335 ASSERT_EQ(0, ioctx.write("foo", bl2, sizeof(buf2), bufsize));
337 ASSERT_EQ(0, ioctx.write("foo", bl2, sizeof(buf2), bufsize*3));
339 ASSERT_EQ(-EINVAL, ioctx.list_snaps("foo", &ss));
340 ObjectReadOperation o;
341 o.list_snaps(&ss, NULL);
342 ASSERT_EQ(-EINVAL, ioctx.operate("foo", &o, NULL));
344 ASSERT_EQ(0, readioctx.list_snaps("foo", &ss));
345 ASSERT_EQ(2u, ss.clones.size());
346 ASSERT_EQ(my_snaps[1], ss.clones[0].cloneid);
347 ASSERT_EQ(1u, ss.clones[0].snaps.size());
348 ASSERT_EQ(my_snaps[1], ss.clones[0].snaps[0]);
349 ASSERT_EQ(2u, ss.clones[0].overlap.size());
350 ASSERT_EQ(0u, ss.clones[0].overlap[0].first);
351 ASSERT_EQ(128u, ss.clones[0].overlap[0].second);
352 ASSERT_EQ(256u, ss.clones[0].overlap[1].first);
353 ASSERT_EQ(128u, ss.clones[0].overlap[1].second);
354 ASSERT_EQ(384u, ss.clones[0].size);
355 ASSERT_EQ(head, ss.clones[1].cloneid);
356 ASSERT_EQ(0u, ss.clones[1].snaps.size());
357 ASSERT_EQ(0u, ss.clones[1].overlap.size());
358 ASSERT_EQ(512u, ss.clones[1].size);
360 ioctx.selfmanaged_snap_rollback("foo", my_snaps[1]);
363 ASSERT_EQ((int)sizeof(buf), ioctx.read("foo", bl3, sizeof(buf), 0));
364 ASSERT_EQ(0, memcmp(bl3.c_str(), buf, sizeof(buf)));
365 ASSERT_EQ((int)sizeof(buf), ioctx.read("foo", bl3, sizeof(buf), bufsize));
366 ASSERT_EQ(0, memcmp(bl3.c_str(), buf, sizeof(buf)));
367 ASSERT_EQ((int)sizeof(buf), ioctx.read("foo", bl3, sizeof(buf), bufsize*2));
368 ASSERT_EQ(0, memcmp(bl3.c_str(), buf, sizeof(buf)));
369 ASSERT_EQ((int)0, ioctx.read("foo", bl3, sizeof(buf), bufsize*3));
371 ASSERT_EQ(0, ioctx.selfmanaged_snap_remove(my_snaps.back()));
373 ASSERT_EQ(0, ioctx.selfmanaged_snap_remove(my_snaps.back()));
378 TEST_F(LibRadosSnapshotsSelfManagedPP, SnapOverlapPP) {
379 std::vector<uint64_t> my_snaps;
381 ASSERT_EQ(0, cluster.ioctx_create(pool_name.c_str(), readioctx));
382 readioctx.set_namespace(nspace);
383 readioctx.snap_set_read(LIBRADOS_SNAP_DIR);
385 my_snaps.push_back(-2);
386 ASSERT_EQ(0, ioctx.selfmanaged_snap_create(&my_snaps.back()));
387 ::std::reverse(my_snaps.begin(), my_snaps.end());
388 ASSERT_EQ(0, ioctx.selfmanaged_snap_set_write_ctx(my_snaps[0], my_snaps));
389 ::std::reverse(my_snaps.begin(), my_snaps.end());
391 memset(buf, 0xcc, sizeof(buf));
393 bl1.append(buf, sizeof(buf));
394 ASSERT_EQ(0, ioctx.write("foo", bl1, sizeof(buf), 0));
395 ASSERT_EQ(0, ioctx.write("foo", bl1, sizeof(buf), bufsize*2));
396 ASSERT_EQ(0, ioctx.write("foo", bl1, sizeof(buf), bufsize*4));
397 ASSERT_EQ(0, ioctx.write("foo", bl1, sizeof(buf), bufsize*6));
398 ASSERT_EQ(0, ioctx.write("foo", bl1, sizeof(buf), bufsize*8));
401 snap_t head = SNAP_HEAD;
402 ASSERT_EQ(0, readioctx.list_snaps("foo", &ss));
403 ASSERT_EQ(1u, ss.clones.size());
404 ASSERT_EQ(head, ss.clones[0].cloneid);
405 ASSERT_EQ(0u, ss.clones[0].snaps.size());
406 ASSERT_EQ(0u, ss.clones[0].overlap.size());
407 ASSERT_EQ(1152u, ss.clones[0].size);
409 my_snaps.push_back(-2);
410 ASSERT_EQ(0, ioctx.selfmanaged_snap_create(&my_snaps.back()));
411 ::std::reverse(my_snaps.begin(), my_snaps.end());
412 ASSERT_EQ(0, ioctx.selfmanaged_snap_set_write_ctx(my_snaps[0], my_snaps));
413 ::std::reverse(my_snaps.begin(), my_snaps.end());
414 char buf2[sizeof(buf)];
415 memset(buf2, 0xdd, sizeof(buf2));
417 bl2.append(buf2, sizeof(buf2));
418 ASSERT_EQ(0, ioctx.write("foo", bl2, sizeof(buf2), bufsize*1));
419 ASSERT_EQ(0, ioctx.write("foo", bl2, sizeof(buf2), bufsize*3));
420 ASSERT_EQ(0, ioctx.write("foo", bl2, sizeof(buf2), bufsize*5));
421 ASSERT_EQ(0, ioctx.write("foo", bl2, sizeof(buf2), bufsize*7));
422 ASSERT_EQ(0, ioctx.write("foo", bl2, sizeof(buf2), bufsize*9));
424 ASSERT_EQ(0, readioctx.list_snaps("foo", &ss));
425 ASSERT_EQ(2u, ss.clones.size());
426 ASSERT_EQ(my_snaps[1], ss.clones[0].cloneid);
427 ASSERT_EQ(1u, ss.clones[0].snaps.size());
428 ASSERT_EQ(my_snaps[1], ss.clones[0].snaps[0]);
429 ASSERT_EQ(5u, ss.clones[0].overlap.size());
430 ASSERT_EQ(0u, ss.clones[0].overlap[0].first);
431 ASSERT_EQ(128u, ss.clones[0].overlap[0].second);
432 ASSERT_EQ(256u, ss.clones[0].overlap[1].first);
433 ASSERT_EQ(128u, ss.clones[0].overlap[1].second);
434 ASSERT_EQ(512u, ss.clones[0].overlap[2].first);
435 ASSERT_EQ(128u, ss.clones[0].overlap[2].second);
436 ASSERT_EQ(768u, ss.clones[0].overlap[3].first);
437 ASSERT_EQ(128u, ss.clones[0].overlap[3].second);
438 ASSERT_EQ(1024u, ss.clones[0].overlap[4].first);
439 ASSERT_EQ(128u, ss.clones[0].overlap[4].second);
440 ASSERT_EQ(1152u, ss.clones[0].size);
441 ASSERT_EQ(head, ss.clones[1].cloneid);
442 ASSERT_EQ(0u, ss.clones[1].snaps.size());
443 ASSERT_EQ(0u, ss.clones[1].overlap.size());
444 ASSERT_EQ(1280u, ss.clones[1].size);
446 my_snaps.push_back(-2);
447 ASSERT_EQ(0, ioctx.selfmanaged_snap_create(&my_snaps.back()));
448 ::std::reverse(my_snaps.begin(), my_snaps.end());
449 ASSERT_EQ(0, ioctx.selfmanaged_snap_set_write_ctx(my_snaps[0], my_snaps));
450 ::std::reverse(my_snaps.begin(), my_snaps.end());
452 char buf3[sizeof(buf)];
453 memset(buf3, 0xee, sizeof(buf3));
455 bl4.append(buf3, sizeof(buf3));
456 ASSERT_EQ(0, ioctx.write("foo", bl2, sizeof(buf3), bufsize*1));
457 ASSERT_EQ(0, ioctx.write("foo", bl2, sizeof(buf3), bufsize*4));
458 ASSERT_EQ(0, ioctx.write("foo", bl2, sizeof(buf3), bufsize*5));
459 ASSERT_EQ(0, ioctx.write("foo", bl2, sizeof(buf3), bufsize*8));
461 ASSERT_EQ(0, readioctx.list_snaps("foo", &ss));
462 ASSERT_EQ(3u, ss.clones.size());
463 ASSERT_EQ(my_snaps[1], ss.clones[0].cloneid);
464 ASSERT_EQ(1u, ss.clones[0].snaps.size());
465 ASSERT_EQ(my_snaps[1], ss.clones[0].snaps[0]);
466 ASSERT_EQ(5u, ss.clones[0].overlap.size());
467 ASSERT_EQ(0u, ss.clones[0].overlap[0].first);
468 ASSERT_EQ(128u, ss.clones[0].overlap[0].second);
469 ASSERT_EQ(256u, ss.clones[0].overlap[1].first);
470 ASSERT_EQ(128u, ss.clones[0].overlap[1].second);
471 ASSERT_EQ(512u, ss.clones[0].overlap[2].first);
472 ASSERT_EQ(128u, ss.clones[0].overlap[2].second);
473 ASSERT_EQ(768u, ss.clones[0].overlap[3].first);
474 ASSERT_EQ(128u, ss.clones[0].overlap[3].second);
475 ASSERT_EQ(1024u, ss.clones[0].overlap[4].first);
476 ASSERT_EQ(128u, ss.clones[0].overlap[4].second);
477 ASSERT_EQ(1152u, ss.clones[0].size);
479 ASSERT_EQ(my_snaps[2], ss.clones[1].cloneid);
480 ASSERT_EQ(1u, ss.clones[1].snaps.size());
481 ASSERT_EQ(my_snaps[2], ss.clones[1].snaps[0]);
482 ASSERT_EQ(4u, ss.clones[1].overlap.size());
483 ASSERT_EQ(0u, ss.clones[1].overlap[0].first);
484 ASSERT_EQ(128u, ss.clones[1].overlap[0].second);
485 ASSERT_EQ(256u, ss.clones[1].overlap[1].first);
486 ASSERT_EQ(256u, ss.clones[1].overlap[1].second);
487 ASSERT_EQ(768u, ss.clones[1].overlap[2].first);
488 ASSERT_EQ(256u, ss.clones[1].overlap[2].second);
489 ASSERT_EQ(1152u, ss.clones[1].overlap[3].first);
490 ASSERT_EQ(128u, ss.clones[1].overlap[3].second);
491 ASSERT_EQ(1280u, ss.clones[1].size);
493 ASSERT_EQ(head, ss.clones[2].cloneid);
494 ASSERT_EQ(0u, ss.clones[2].snaps.size());
495 ASSERT_EQ(0u, ss.clones[2].overlap.size());
496 ASSERT_EQ(1280u, ss.clones[2].size);
498 ASSERT_EQ(0, ioctx.selfmanaged_snap_remove(my_snaps.back()));
500 ASSERT_EQ(0, ioctx.selfmanaged_snap_remove(my_snaps.back()));
502 ASSERT_EQ(0, ioctx.selfmanaged_snap_remove(my_snaps.back()));
507 TEST_F(LibRadosSnapshotsSelfManagedPP, Bug11677) {
508 std::vector<uint64_t> my_snaps;
509 my_snaps.push_back(-2);
510 ASSERT_EQ(0, ioctx.selfmanaged_snap_create(&my_snaps.back()));
511 ::std::reverse(my_snaps.begin(), my_snaps.end());
512 ASSERT_EQ(0, ioctx.selfmanaged_snap_set_write_ctx(my_snaps[0], my_snaps));
513 ::std::reverse(my_snaps.begin(), my_snaps.end());
516 char *buf = (char *)new char[bsize];
517 memset(buf, 0xcc, bsize);
519 bl1.append(buf, bsize);
520 ASSERT_EQ(0, ioctx.write("foo", bl1, bsize, 0));
522 my_snaps.push_back(-2);
523 ASSERT_EQ(0, ioctx.selfmanaged_snap_create(&my_snaps.back()));
524 ::std::reverse(my_snaps.begin(), my_snaps.end());
525 ASSERT_EQ(0, ioctx.selfmanaged_snap_set_write_ctx(my_snaps[0], my_snaps));
526 ::std::reverse(my_snaps.begin(), my_snaps.end());
528 std::unique_ptr<librados::ObjectWriteOperation> op(new librados::ObjectWriteOperation());
531 ASSERT_EQ(0, ioctx.operate("foo", op.get()));
533 ASSERT_EQ(0, ioctx.selfmanaged_snap_remove(my_snaps.back()));
535 ASSERT_EQ(0, ioctx.selfmanaged_snap_remove(my_snaps.back()));
537 ioctx.snap_set_read(LIBRADOS_SNAP_HEAD);
542 TEST_F(LibRadosSnapshotsEC, SnapList) {
544 memset(buf, 0xcc, sizeof(buf));
545 ASSERT_EQ(0, rados_write(ioctx, "foo", buf, sizeof(buf), 0));
546 ASSERT_EQ(0, rados_ioctx_snap_create(ioctx, "snap1"));
547 rados_snap_t snaps[10];
548 EXPECT_EQ(1, rados_ioctx_snap_list(ioctx, snaps,
549 sizeof(snaps) / sizeof(snaps[0])));
551 EXPECT_EQ(0, rados_ioctx_snap_lookup(ioctx, "snap1", &rid));
552 EXPECT_EQ(rid, snaps[0]);
553 EXPECT_EQ(0, rados_ioctx_snap_remove(ioctx, "snap1"));
556 TEST_F(LibRadosSnapshotsECPP, SnapListPP) {
558 memset(buf, 0xcc, sizeof(buf));
560 bl1.append(buf, sizeof(buf));
561 ASSERT_EQ(0, ioctx.write("foo", bl1, sizeof(buf), 0));
562 ASSERT_EQ(0, ioctx.snap_create("snap1"));
563 std::vector<snap_t> snaps;
564 EXPECT_EQ(0, ioctx.snap_list(&snaps));
565 EXPECT_EQ(1U, snaps.size());
567 EXPECT_EQ(0, ioctx.snap_lookup("snap1", &rid));
568 EXPECT_EQ(rid, snaps[0]);
569 EXPECT_EQ(0, ioctx.snap_remove("snap1"));
572 TEST_F(LibRadosSnapshotsEC, SnapRemove) {
574 memset(buf, 0xcc, sizeof(buf));
575 ASSERT_EQ(0, rados_write(ioctx, "foo", buf, sizeof(buf), 0));
576 ASSERT_EQ(0, rados_ioctx_snap_create(ioctx, "snap1"));
578 ASSERT_EQ(0, rados_ioctx_snap_lookup(ioctx, "snap1", &rid));
579 ASSERT_EQ(-EEXIST, rados_ioctx_snap_create(ioctx, "snap1"));
580 ASSERT_EQ(0, rados_ioctx_snap_remove(ioctx, "snap1"));
581 ASSERT_EQ(-ENOENT, rados_ioctx_snap_lookup(ioctx, "snap1", &rid));
584 TEST_F(LibRadosSnapshotsECPP, SnapRemovePP) {
586 memset(buf, 0xcc, sizeof(buf));
588 bl1.append(buf, sizeof(buf));
589 ASSERT_EQ(0, ioctx.write("foo", bl1, sizeof(buf), 0));
590 ASSERT_EQ(0, ioctx.snap_create("snap1"));
592 ASSERT_EQ(0, ioctx.snap_lookup("snap1", &rid));
593 ASSERT_EQ(0, ioctx.snap_remove("snap1"));
594 ASSERT_EQ(-ENOENT, ioctx.snap_lookup("snap1", &rid));
597 TEST_F(LibRadosSnapshotsEC, Rollback) {
599 memset(buf, 0xcc, sizeof(buf));
600 ASSERT_EQ(0, rados_write(ioctx, "foo", buf, sizeof(buf), 0));
601 ASSERT_EQ(0, rados_ioctx_snap_create(ioctx, "snap1"));
602 char buf2[sizeof(buf)];
603 memset(buf2, 0xdd, sizeof(buf2));
604 EXPECT_EQ(0, rados_write_full(ioctx, "foo", buf2, sizeof(buf2)));
605 EXPECT_EQ(0, rados_ioctx_snap_rollback(ioctx, "foo", "snap1"));
606 char buf3[sizeof(buf)];
607 EXPECT_EQ((int)sizeof(buf3), rados_read(ioctx, "foo", buf3, sizeof(buf3), 0));
608 EXPECT_EQ(0, memcmp(buf, buf3, sizeof(buf)));
609 EXPECT_EQ(0, rados_ioctx_snap_remove(ioctx, "snap1"));
612 TEST_F(LibRadosSnapshotsECPP, RollbackPP) {
614 memset(buf, 0xcc, sizeof(buf));
616 bl1.append(buf, sizeof(buf));
617 ASSERT_EQ(0, ioctx.write("foo", bl1, sizeof(buf), 0));
618 ASSERT_EQ(0, ioctx.snap_create("snap1"));
619 char buf2[sizeof(buf)];
620 memset(buf2, 0xdd, sizeof(buf2));
622 bl2.append(buf2, sizeof(buf2));
623 EXPECT_EQ(0, ioctx.write_full("foo", bl2));
624 EXPECT_EQ(0, ioctx.snap_rollback("foo", "snap1"));
626 EXPECT_EQ((int)sizeof(buf), ioctx.read("foo", bl3, sizeof(buf), 0));
627 EXPECT_EQ(0, memcmp(buf, bl3.c_str(), sizeof(buf)));
628 EXPECT_EQ(0, ioctx.snap_remove("snap1"));
631 TEST_F(LibRadosSnapshotsEC, SnapGetName) {
633 memset(buf, 0xcc, sizeof(buf));
634 ASSERT_EQ(0, rados_write(ioctx, "foo", buf, sizeof(buf), 0));
635 ASSERT_EQ(0, rados_ioctx_snap_create(ioctx, "snapfoo"));
637 EXPECT_EQ(0, rados_ioctx_snap_lookup(ioctx, "snapfoo", &rid));
638 EXPECT_EQ(-ENOENT, rados_ioctx_snap_lookup(ioctx, "snapbar", &rid));
640 memset(name, 0, sizeof(name));
641 EXPECT_EQ(0, rados_ioctx_snap_get_name(ioctx, rid, name, sizeof(name)));
643 EXPECT_EQ(0, rados_ioctx_snap_get_stamp(ioctx, rid, &snaptime));
644 EXPECT_EQ(0, strcmp(name, "snapfoo"));
645 EXPECT_EQ(0, rados_ioctx_snap_remove(ioctx, "snapfoo"));
648 TEST_F(LibRadosSnapshotsECPP, SnapGetNamePP) {
650 memset(buf, 0xcc, sizeof(buf));
652 bl.append(buf, sizeof(buf));
653 ASSERT_EQ(0, ioctx.write("foo", bl, sizeof(buf), 0));
654 ASSERT_EQ(0, ioctx.snap_create("snapfoo"));
656 EXPECT_EQ(0, ioctx.snap_lookup("snapfoo", &rid));
657 EXPECT_EQ(-ENOENT, ioctx.snap_lookup("snapbar", &rid));
659 EXPECT_EQ(0, ioctx.snap_get_name(rid, &name));
661 EXPECT_EQ(0, ioctx.snap_get_stamp(rid, &snaptime));
662 EXPECT_EQ(0, strcmp(name.c_str(), "snapfoo"));
663 EXPECT_EQ(0, ioctx.snap_remove("snapfoo"));
666 TEST_F(LibRadosSnapshotsSelfManagedEC, Snap) {
667 std::vector<uint64_t> my_snaps;
668 my_snaps.push_back(-2);
669 ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_create(ioctx, &my_snaps.back()));
670 ::std::reverse(my_snaps.begin(), my_snaps.end());
671 ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_set_write_ctx(ioctx, my_snaps[0],
672 &my_snaps[0], my_snaps.size()));
673 ::std::reverse(my_snaps.begin(), my_snaps.end());
674 int bsize = alignment;
675 char *buf = (char *)new char[bsize];
676 memset(buf, 0xcc, bsize);
677 ASSERT_EQ(0, rados_write(ioctx, "foo", buf, bsize, 0));
679 my_snaps.push_back(-2);
680 rados_completion_t completion;
681 ASSERT_EQ(0, rados_aio_create_completion(nullptr, nullptr, nullptr,
683 rados_aio_ioctx_selfmanaged_snap_create(ioctx, &my_snaps.back(), completion);
684 ASSERT_EQ(0, rados_aio_wait_for_complete(completion));
685 rados_aio_release(completion);
686 ::std::reverse(my_snaps.begin(), my_snaps.end());
687 ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_set_write_ctx(ioctx, my_snaps[0],
688 &my_snaps[0], my_snaps.size()));
689 ::std::reverse(my_snaps.begin(), my_snaps.end());
690 char *buf2 = (char *)new char[bsize];
691 memset(buf2, 0xdd, bsize);
692 ASSERT_EQ(0, rados_write(ioctx, "foo", buf2, bsize, bsize));
693 rados_ioctx_snap_set_read(ioctx, my_snaps[1]-1);
694 char *buf3 = (char *)new char[bsize*2];
695 ASSERT_EQ(-ENOENT, rados_read(ioctx, "foo", buf3, bsize*2, 0));
697 rados_ioctx_snap_set_read(ioctx, my_snaps[1]);
698 ASSERT_EQ(bsize, rados_read(ioctx, "foo", buf3, bsize*2, 0));
699 ASSERT_EQ(0, memcmp(buf3, buf, bsize));
701 ASSERT_EQ(0, rados_aio_create_completion(nullptr, nullptr, nullptr,
703 rados_aio_ioctx_selfmanaged_snap_remove(ioctx, my_snaps.back(), completion);
704 ASSERT_EQ(0, rados_aio_wait_for_complete(completion));
705 rados_aio_release(completion);
707 ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_remove(ioctx, my_snaps.back()));
709 rados_ioctx_snap_set_read(ioctx, LIBRADOS_SNAP_HEAD);
710 ASSERT_EQ(0, rados_remove(ioctx, "foo"));
716 TEST_F(LibRadosSnapshotsSelfManagedEC, Rollback) {
717 std::vector<uint64_t> my_snaps;
718 my_snaps.push_back(-2);
719 ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_create(ioctx, &my_snaps.back()));
720 ::std::reverse(my_snaps.begin(), my_snaps.end());
721 ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_set_write_ctx(ioctx, my_snaps[0],
722 &my_snaps[0], my_snaps.size()));
723 ::std::reverse(my_snaps.begin(), my_snaps.end());
724 int bsize = alignment;
725 char *buf = (char *)new char[bsize];
726 memset(buf, 0xcc, bsize);
727 ASSERT_EQ(0, rados_write(ioctx, "foo", buf, bsize, 0));
729 my_snaps.push_back(-2);
730 ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_create(ioctx, &my_snaps.back()));
731 ::std::reverse(my_snaps.begin(), my_snaps.end());
732 ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_set_write_ctx(ioctx, my_snaps[0],
733 &my_snaps[0], my_snaps.size()));
734 ::std::reverse(my_snaps.begin(), my_snaps.end());
735 char *buf2 = (char *)new char[bsize];
736 memset(buf2, 0xdd, bsize);
738 ASSERT_EQ(0, rados_write(ioctx, "foo", buf2, bsize, bsize));
739 rados_ioctx_selfmanaged_snap_rollback(ioctx, "foo", my_snaps[1]);
740 char *buf3 = (char *)new char[bsize*2];
741 ASSERT_EQ(bsize, rados_read(ioctx, "foo", buf3, bsize*2, 0));
742 ASSERT_EQ(0, memcmp(buf3, buf, bsize));
744 ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_remove(ioctx, my_snaps.back()));
746 ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_remove(ioctx, my_snaps.back()));
748 ASSERT_EQ(0, rados_remove(ioctx, "foo"));
754 TEST_F(LibRadosSnapshotsSelfManagedECPP, SnapPP) {
755 std::vector<uint64_t> my_snaps;
756 my_snaps.push_back(-2);
757 ASSERT_EQ(0, ioctx.selfmanaged_snap_create(&my_snaps.back()));
758 ::std::reverse(my_snaps.begin(), my_snaps.end());
759 ASSERT_EQ(0, ioctx.selfmanaged_snap_set_write_ctx(my_snaps[0], my_snaps));
760 ::std::reverse(my_snaps.begin(), my_snaps.end());
761 int bsize = alignment;
762 char *buf = (char *)new char[bsize];
763 memset(buf, 0xcc, bsize);
765 bl1.append(buf, bsize);
766 ASSERT_EQ(0, ioctx.write("foo", bl1, bsize, 0));
768 my_snaps.push_back(-2);
769 librados::AioCompletion *completion = cluster.aio_create_completion();
770 ioctx.aio_selfmanaged_snap_create(&my_snaps.back(), completion);
771 ASSERT_EQ(0, completion->wait_for_complete());
772 completion->release();
773 ::std::reverse(my_snaps.begin(), my_snaps.end());
774 ASSERT_EQ(0, ioctx.selfmanaged_snap_set_write_ctx(my_snaps[0], my_snaps));
775 ::std::reverse(my_snaps.begin(), my_snaps.end());
776 char *buf2 = (char *)new char[bsize];
777 memset(buf2, 0xdd, bsize);
779 bl2.append(buf2, bsize);
780 // Add another aligned buffer
781 ASSERT_EQ(0, ioctx.write("foo", bl2, bsize, bsize));
783 ioctx.snap_set_read(my_snaps[1]);
785 ASSERT_EQ(bsize, ioctx.read("foo", bl3, bsize*3, 0));
786 ASSERT_EQ(0, memcmp(bl3.c_str(), buf, bsize));
788 completion = cluster.aio_create_completion();
789 ioctx.aio_selfmanaged_snap_remove(my_snaps.back(), completion);
790 ASSERT_EQ(0, completion->wait_for_complete());
791 completion->release();
793 ASSERT_EQ(0, ioctx.selfmanaged_snap_remove(my_snaps.back()));
795 ioctx.snap_set_read(LIBRADOS_SNAP_HEAD);
796 ASSERT_EQ(0, ioctx.remove("foo"));
801 TEST_F(LibRadosSnapshotsSelfManagedECPP, RollbackPP) {
802 std::vector<uint64_t> my_snaps;
804 ASSERT_EQ(0, cluster.ioctx_create(pool_name.c_str(), readioctx));
805 readioctx.set_namespace(nspace);
806 readioctx.snap_set_read(LIBRADOS_SNAP_DIR);
808 my_snaps.push_back(-2);
809 ASSERT_EQ(0, ioctx.selfmanaged_snap_create(&my_snaps.back()));
810 ::std::reverse(my_snaps.begin(), my_snaps.end());
811 ASSERT_EQ(0, ioctx.selfmanaged_snap_set_write_ctx(my_snaps[0], my_snaps));
812 ::std::reverse(my_snaps.begin(), my_snaps.end());
813 int bsize = alignment;
814 char *buf = (char *)new char[bsize];
815 memset(buf, 0xcc, bsize);
817 bl1.append(buf, bsize);
818 //Write 3 consecutive buffers
819 ASSERT_EQ(0, ioctx.write("foo", bl1, bsize, 0));
820 ASSERT_EQ(0, ioctx.write("foo", bl1, bsize, bsize));
821 ASSERT_EQ(0, ioctx.write("foo", bl1, bsize, bsize*2));
825 snap_t head = SNAP_HEAD;
826 ASSERT_EQ(0, readioctx.list_snaps("foo", &ss));
827 ASSERT_EQ(1u, ss.clones.size());
828 ASSERT_EQ(head, ss.clones[0].cloneid);
829 ASSERT_EQ(0u, ss.clones[0].snaps.size());
830 ASSERT_EQ(0u, ss.clones[0].overlap.size());
831 ASSERT_EQ((unsigned)(bsize*3), ss.clones[0].size);
833 my_snaps.push_back(-2);
834 ASSERT_EQ(0, ioctx.selfmanaged_snap_create(&my_snaps.back()));
835 ::std::reverse(my_snaps.begin(), my_snaps.end());
836 ASSERT_EQ(0, ioctx.selfmanaged_snap_set_write_ctx(my_snaps[0], my_snaps));
837 ::std::reverse(my_snaps.begin(), my_snaps.end());
838 char *buf2 = (char *)new char[bsize];
839 memset(buf2, 0xdd, bsize);
841 bl2.append(buf2, bsize);
842 //Change the middle buffer
843 //ASSERT_EQ(0, ioctx.write("foo", bl2, sizeof(buf2), bufsize));
845 ASSERT_EQ(0, ioctx.write("foo", bl2, bsize, bsize*3));
847 ASSERT_EQ(-EINVAL, ioctx.list_snaps("foo", &ss));
848 ObjectReadOperation o;
849 o.list_snaps(&ss, NULL);
850 ASSERT_EQ(-EINVAL, ioctx.operate("foo", &o, NULL));
852 ASSERT_EQ(0, readioctx.list_snaps("foo", &ss));
853 ASSERT_EQ(2u, ss.clones.size());
854 ASSERT_EQ(my_snaps[1], ss.clones[0].cloneid);
855 ASSERT_EQ(1u, ss.clones[0].snaps.size());
856 ASSERT_EQ(my_snaps[1], ss.clones[0].snaps[0]);
857 ASSERT_EQ(1u, ss.clones[0].overlap.size());
858 ASSERT_EQ(0u, ss.clones[0].overlap[0].first);
859 ASSERT_EQ((unsigned)bsize*3, ss.clones[0].overlap[0].second);
860 ASSERT_EQ((unsigned)bsize*3, ss.clones[0].size);
861 ASSERT_EQ(head, ss.clones[1].cloneid);
862 ASSERT_EQ(0u, ss.clones[1].snaps.size());
863 ASSERT_EQ(0u, ss.clones[1].overlap.size());
864 ASSERT_EQ((unsigned)bsize*4, ss.clones[1].size);
866 ioctx.selfmanaged_snap_rollback("foo", my_snaps[1]);
869 ASSERT_EQ(bsize, ioctx.read("foo", bl3, bsize, 0));
870 ASSERT_EQ(0, memcmp(bl3.c_str(), buf, bsize));
871 ASSERT_EQ(bsize, ioctx.read("foo", bl3, bsize, bsize));
872 ASSERT_EQ(0, memcmp(bl3.c_str(), buf, bsize));
873 ASSERT_EQ(bsize, ioctx.read("foo", bl3, bsize, bsize*2));
874 ASSERT_EQ(0, memcmp(bl3.c_str(), buf, bsize));
875 ASSERT_EQ(0, ioctx.read("foo", bl3, bsize, bsize*3));
877 ASSERT_EQ(0, ioctx.selfmanaged_snap_remove(my_snaps.back()));
879 ASSERT_EQ(0, ioctx.selfmanaged_snap_remove(my_snaps.back()));
887 TEST_F(LibRadosSnapshotsSelfManagedECPP, Bug11677) {
888 std::vector<uint64_t> my_snaps;
889 my_snaps.push_back(-2);
890 ASSERT_EQ(0, ioctx.selfmanaged_snap_create(&my_snaps.back()));
891 ::std::reverse(my_snaps.begin(), my_snaps.end());
892 ASSERT_EQ(0, ioctx.selfmanaged_snap_set_write_ctx(my_snaps[0], my_snaps));
893 ::std::reverse(my_snaps.begin(), my_snaps.end());
895 int bsize = alignment;
896 char *buf = (char *)new char[bsize];
897 memset(buf, 0xcc, bsize);
899 bl1.append(buf, bsize);
900 ASSERT_EQ(0, ioctx.write("foo", bl1, bsize, 0));
902 my_snaps.push_back(-2);
903 ASSERT_EQ(0, ioctx.selfmanaged_snap_create(&my_snaps.back()));
904 ::std::reverse(my_snaps.begin(), my_snaps.end());
905 ASSERT_EQ(0, ioctx.selfmanaged_snap_set_write_ctx(my_snaps[0], my_snaps));
906 ::std::reverse(my_snaps.begin(), my_snaps.end());
908 std::unique_ptr<librados::ObjectWriteOperation> op(new librados::ObjectWriteOperation());
911 ASSERT_EQ(0, ioctx.operate("foo", op.get()));
913 ASSERT_EQ(0, ioctx.selfmanaged_snap_remove(my_snaps.back()));
915 ASSERT_EQ(0, ioctx.selfmanaged_snap_remove(my_snaps.back()));
917 ioctx.snap_set_read(LIBRADOS_SNAP_HEAD);