librbd: normalization for group C API

Signed-off-by: Mykola Golub <mgolub@suse.com>

diff --git a/src/librbd/librbd.cc b/src/librbd/librbd.cc
index d5fb9da11bfe7b1a85c94df51ea7e338e547a200..6734a52a500bea7cef03865de19be4c1c12304f1 100644 (file)
--- a/src/librbd/librbd.cc
+++ b/src/librbd/librbd.cc
@@ -4532,7 +4532,6 @@ extern "C" int rbd_group_list(rados_ioctx_t p, char *names, size_t *size)
     return -EINVAL;
   }
 
-  names[expected_size] = '\0';
   for (int i = 0; i < (int)cpp_names.size(); i++) {
     const char* name = cpp_names[i].c_str();
     tracepoint(librbd, group_list_entry, name);
@@ -4671,7 +4670,7 @@ extern "C" int rbd_group_image_list(rados_ioctx_t group_p,
     group_image_status_cpp_to_c(cpp_images[i], &images[i]);
   }
 
-  r = cpp_images.size();
+  r = *image_size = cpp_images.size();
   tracepoint(librbd, group_image_list_exit, r);
   return r;
 }
@@ -4800,9 +4799,9 @@ extern "C" int rbd_group_snap_list(rados_ioctx_t group_p,
     group_snap_info_cpp_to_c(cpp_snaps[i], &snaps[i]);
   }
 
-  *snaps_size = cpp_snaps.size();
-  tracepoint(librbd, group_snap_list_exit, 0);
-  return 0;
+  r = *snaps_size = cpp_snaps.size();
+  tracepoint(librbd, group_snap_list_exit, r);
+  return r;
 }
 
 extern "C" int rbd_group_snap_list_cleanup(rbd_group_snap_info_t *snaps,

diff --git a/src/pybind/rbd/rbd.pyx b/src/pybind/rbd/rbd.pyx
index a05d4b802bdb9f562213ce20b3d202f4a8ce1aaa..65c2e328feb267995002a1e10d5d3d3075b2eb33 100644 (file)
--- a/src/pybind/rbd/rbd.pyx
+++ b/src/pybind/rbd/rbd.pyx
@@ -3653,7 +3653,6 @@ cdef class GroupImageIterator(object):
                                            &self.num_images)
 
             if ret >= 0:
-                self.num_images = ret
                 break
             elif ret != -errno.ERANGE:
                 raise make_ex(ret, 'error listing images for group %s' % (group.name,), group_errno_to_exception)
@@ -3703,7 +3702,7 @@ cdef class GroupSnapIterator(object):
                                           sizeof(rbd_group_snap_info_t),
                                           &self.num_snaps)
 
-            if ret == 0:
+            if ret >= 0:
                 break
             elif ret != -errno.ERANGE:
                 raise make_ex(ret, 'error listing snapshots for group %s' % (group.name,), group_errno_to_exception)

diff --git a/src/test/librbd/test_Groups.cc b/src/test/librbd/test_Groups.cc
index 4a5d71b7fb5836431e4f9c76d874ae55b39278b1..70611496e001608e6753f6ee700fc835992cdd67 100644 (file)
--- a/src/test/librbd/test_Groups.cc
+++ b/src/test/librbd/test_Groups.cc
@@ -1,40 +1,16 @@
 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
 // vim: ts=8 sw=2 smarttab
+
 #include "test/librbd/test_fixture.h"
 #include "test/librbd/test_support.h"
-#include "include/int_types.h"
-#include "include/stringify.h"
-#include "include/rados/librados.h"
+#include "include/rbd/librbd.h"
 #include "include/rbd/librbd.hpp"
-#include "common/Cond.h"
-#include "common/errno.h"
-#include "common/Mutex.h"
-#include "common/RWLock.h"
-#include "cls/lock/cls_lock_client.h"
-#include "cls/lock/cls_lock_types.h"
-#include "librbd/internal.h"
-#include "librbd/ImageCtx.h"
-#include "librbd/ImageWatcher.h"
-#include "librbd/WatchNotifyTypes.h"
-#include "librbd/io/AioCompletion.h"
-#include "librbd/io/ImageRequestWQ.h"
 #include "test/librados/test.h"
 #include "gtest/gtest.h"
-#include <boost/assign/std/set.hpp>
-#include <boost/assign/std/map.hpp>
-#include <boost/bind.hpp>
+
 #include <boost/scope_exit.hpp>
-#include <boost/thread/thread.hpp>
-#include <iostream>
-#include <map>
-#include <set>
-#include <sstream>
 #include <vector>
 
-using namespace ceph;
-using namespace boost::assign;
-using namespace librbd::watch_notify;
-
 void register_test_groups() {
 }
 
@@ -43,6 +19,30 @@ class TestGroup : public TestFixture {
 };
 
 TEST_F(TestGroup, group_create)
+{
+  rados_ioctx_t ioctx;
+  rados_ioctx_create(_cluster, _pool_name.c_str(), &ioctx);
+  BOOST_SCOPE_EXIT(ioctx) {
+    rados_ioctx_destroy(ioctx);
+  } BOOST_SCOPE_EXIT_END;
+
+  librbd::RBD rbd;
+  ASSERT_EQ(0, rbd_group_create(ioctx, "mygroup"));
+
+  size_t size = 0;
+  ASSERT_EQ(-ERANGE, rbd_group_list(ioctx, NULL, &size));
+  ASSERT_EQ(strlen("mygroup") + 1, size);
+
+  char groups[80];
+  ASSERT_EQ(strlen("mygroup") + 1, rbd_group_list(ioctx, groups, &size));
+  ASSERT_STREQ("mygroup", groups);
+
+  ASSERT_EQ(0, rbd_group_remove(ioctx, "mygroup"));
+
+  ASSERT_EQ(0, rbd_group_list(ioctx, groups, &size));
+}
+
+TEST_F(TestGroup, group_createPP)
 {
   librados::IoCtx ioctx;
   ASSERT_EQ(0, _rados.ioctx_create(_pool_name.c_str(), ioctx));
@@ -72,6 +72,76 @@ TEST_F(TestGroup, add_image)
 {
   REQUIRE_FORMAT_V2();
 
+  rados_ioctx_t ioctx;
+  rados_ioctx_create(_cluster, _pool_name.c_str(), &ioctx);
+  BOOST_SCOPE_EXIT(ioctx) {
+    rados_ioctx_destroy(ioctx);
+  } BOOST_SCOPE_EXIT_END;
+
+  const char *group_name = "mycg";
+  ASSERT_EQ(0, rbd_group_create(ioctx, group_name));
+
+  rbd_image_t image;
+  ASSERT_EQ(0, rbd_open(ioctx, m_image_name.c_str(), &image, NULL));
+  BOOST_SCOPE_EXIT(image) {
+    EXPECT_EQ(0, rbd_close(image));
+  } BOOST_SCOPE_EXIT_END;
+
+  uint64_t features;
+  ASSERT_EQ(0, rbd_get_features(image, &features));
+  ASSERT_TRUE((features & RBD_FEATURE_OPERATIONS) == 0ULL);
+
+  uint64_t op_features;
+  ASSERT_EQ(0, rbd_get_op_features(image, &op_features));
+  ASSERT_TRUE((op_features & RBD_OPERATION_FEATURE_GROUP) == 0ULL);
+
+  ASSERT_EQ(0, rbd_group_image_add(ioctx, group_name, ioctx,
+                                   m_image_name.c_str()));
+
+  ASSERT_EQ(0, rbd_get_features(image, &features));
+  ASSERT_TRUE((features & RBD_FEATURE_OPERATIONS) ==
+                RBD_FEATURE_OPERATIONS);
+  ASSERT_EQ(0, rbd_get_op_features(image, &op_features));
+  ASSERT_TRUE((op_features & RBD_OPERATION_FEATURE_GROUP) ==
+                RBD_OPERATION_FEATURE_GROUP);
+
+  size_t num_images = 0;
+  ASSERT_EQ(-ERANGE, rbd_group_image_list(ioctx, group_name, NULL,
+                                          sizeof(rbd_group_image_info_t),
+                                          &num_images));
+  ASSERT_EQ(1, num_images);
+
+  rbd_group_image_info_t images[1];
+  ASSERT_EQ(1, rbd_group_image_list(ioctx, group_name, images,
+                                    sizeof(rbd_group_image_info_t),
+                                    &num_images));
+
+  ASSERT_EQ(m_image_name, images[0].name);
+  ASSERT_EQ(rados_ioctx_get_id(ioctx), images[0].pool);
+
+  ASSERT_EQ(0, rbd_group_image_list_cleanup(images,
+                                            sizeof(rbd_group_image_info_t),
+                                            num_images));
+  ASSERT_EQ(0, rbd_group_image_remove(ioctx, group_name, ioctx,
+                                      m_image_name.c_str()));
+
+  ASSERT_EQ(0, rbd_get_features(image, &features));
+  ASSERT_TRUE((features & RBD_FEATURE_OPERATIONS) == 0ULL);
+  ASSERT_EQ(0, rbd_get_op_features(image, &op_features));
+  ASSERT_TRUE((op_features & RBD_OPERATION_FEATURE_GROUP) == 0ULL);
+
+  ASSERT_EQ(0, rbd_group_image_list(ioctx, group_name, images,
+                                    sizeof(rbd_group_image_info_t),
+                                    &num_images));
+  ASSERT_EQ(0, num_images);
+
+  ASSERT_EQ(0, rbd_group_remove(ioctx, group_name));
+}
+
+TEST_F(TestGroup, add_imagePP)
+{
+  REQUIRE_FORMAT_V2();
+
   librados::IoCtx ioctx;
   ASSERT_EQ(0, _rados.ioctx_create(_pool_name.c_str(), ioctx));
 
@@ -119,12 +189,59 @@ TEST_F(TestGroup, add_image)
   ASSERT_EQ(0, rbd.group_image_list(ioctx, group_name, &images,
                                     sizeof(librbd::group_image_info_t)));
   ASSERT_EQ(0U, images.size());
+
+  ASSERT_EQ(0, rbd.group_remove(ioctx, group_name));
 }
 
 TEST_F(TestGroup, add_snapshot)
 {
   REQUIRE_FORMAT_V2();
 
+  rados_ioctx_t ioctx;
+  rados_ioctx_create(_cluster, _pool_name.c_str(), &ioctx);
+  BOOST_SCOPE_EXIT(ioctx) {
+    rados_ioctx_destroy(ioctx);
+  } BOOST_SCOPE_EXIT_END;
+
+  const char *group_name = "snap_group";
+  const char *snap_name = "snap_snapshot";
+
+  ASSERT_EQ(0, rbd_group_create(ioctx, group_name));
+
+  ASSERT_EQ(0, rbd_group_image_add(ioctx, group_name, ioctx,
+                                   m_image_name.c_str()));
+
+  ASSERT_EQ(0, rbd_group_snap_create(ioctx, group_name, snap_name));
+
+  size_t num_snaps = 0;
+  ASSERT_EQ(-ERANGE, rbd_group_snap_list(ioctx, group_name, NULL,
+                                         sizeof(rbd_group_snap_info_t),
+                                         &num_snaps));
+  ASSERT_EQ(1U, num_snaps);
+
+  rbd_group_snap_info_t snaps[1];
+  ASSERT_EQ(1, rbd_group_snap_list(ioctx, group_name, snaps,
+                                   sizeof(rbd_group_snap_info_t),
+                                   &num_snaps));
+
+  ASSERT_STREQ(snap_name, snaps[0].name);
+
+  ASSERT_EQ(0, rbd_group_snap_list_cleanup(snaps, sizeof(rbd_group_snap_info_t),
+                                           num_snaps));
+  ASSERT_EQ(0, rbd_group_snap_remove(ioctx, group_name, snap_name));
+
+  ASSERT_EQ(0, rbd_group_snap_list(ioctx, group_name, snaps,
+                                   sizeof(rbd_group_snap_info_t),
+                                   &num_snaps));
+  ASSERT_EQ(0U, num_snaps);
+
+  ASSERT_EQ(0, rbd_group_remove(ioctx, group_name));
+}
+
+TEST_F(TestGroup, add_snapshotPP)
+{
+  REQUIRE_FORMAT_V2();
+
   librados::IoCtx ioctx;
   ASSERT_EQ(0, _rados.ioctx_create(_pool_name.c_str(), ioctx));
 
@@ -152,4 +269,6 @@ TEST_F(TestGroup, add_snapshot)
   ASSERT_EQ(0, rbd.group_snap_list(ioctx, group_name, &snaps,
                                    sizeof(librbd::group_snap_info_t)));
   ASSERT_EQ(0U, snaps.size());
+
+  ASSERT_EQ(0, rbd.group_remove(ioctx, group_name));
 }