kvstorebench_LDADD = librados.la $(LIBGLOBAL_LDA)
bin_DEBUGPROGRAMS += kvstorebench
-multi_stress_watch_SOURCES = test/multi_stress_watch.cc test/rados-api/test.cc
+multi_stress_watch_SOURCES = test/multi_stress_watch.cc test/librados/test.cc
multi_stress_watch_LDADD = librados.la $(LIBGLOBAL_LDA)
bin_DEBUGPROGRAMS += multi_stress_watch
unittest_texttable_CXXFLAGS = ${AM_CXXFLAGS} ${UNITTEST_CXXFLAGS}
check_PROGRAMS += unittest_texttable
-test_librbd_SOURCES = test/librbd/test_librbd.cc test/rados-api/test.cc
+test_librbd_SOURCES = test/librbd/test_librbd.cc test/librados/test.cc
test_librbd_LDADD = librbd.la librados.la ${UNITTEST_STATIC_LDADD}
test_librbd_CXXFLAGS = ${AM_CXXFLAGS} ${UNITTEST_CXXFLAGS}
bin_DEBUGPROGRAMS += test_librbd
bin_DEBUGPROGRAMS += test_librbd_fsx
test_cls_rbd_SOURCES = test/cls_rbd/test_cls_rbd.cc \
- test/rados-api/test.cc \
+ test/librados/test.cc \
cls/rbd/cls_rbd_client.cc \
cls/lock/cls_lock_client.cc \
cls/lock/cls_lock_types.cc \
bin_DEBUGPROGRAMS += test_cls_rbd
test_cls_refcount_SOURCES = test/cls_refcount/test_cls_refcount.cc \
- test/rados-api/test.cc
+ test/librados/test.cc
test_cls_refcount_LDADD = librados.la libcls_refcount_client.a ${UNITTEST_STATIC_LDADD}
test_cls_refcount_CXXFLAGS = ${AM_CXXFLAGS} ${UNITTEST_CXXFLAGS}
bin_DEBUGPROGRAMS += test_cls_refcount
-test_cls_lock_SOURCES = test/cls_lock/test_cls_lock.cc test/rados-api/test.cc
+test_cls_lock_SOURCES = test/cls_lock/test_cls_lock.cc test/librados/test.cc
test_cls_lock_LDFLAGS = ${AM_LDFLAGS}
test_cls_lock_LDADD = libcls_lock_client.a librados.la ${UNITTEST_STATIC_LDADD}
test_cls_lock_CXXFLAGS = ${AM_CXXFLAGS} ${UNITTEST_CXXFLAGS}
if WITH_RADOSGW
test_cls_rgw_SOURCES = test/cls_rgw/test_cls_rgw.cc \
- test/rados-api/test.cc
+ test/librados/test.cc
test_cls_rgw_LDADD = librados.la libcls_rgw_client.a ${UNITTEST_STATIC_LDADD}
test_cls_rgw_CXXFLAGS = ${AM_CXXFLAGS} ${UNITTEST_CXXFLAGS}
bin_DEBUGPROGRAMS += test_cls_rgw
endif
-test_rados_api_io_SOURCES = test/rados-api/io.cc test/rados-api/test.cc
+test_rados_api_io_SOURCES = test/librados/io.cc test/librados/test.cc
test_rados_api_io_LDFLAGS = ${AM_LDFLAGS}
test_rados_api_io_LDADD = librados.la ${UNITTEST_STATIC_LDADD}
test_rados_api_io_CXXFLAGS = ${AM_CXXFLAGS} ${UNITTEST_CXXFLAGS}
bin_DEBUGPROGRAMS += test_rados_api_io
-test_rados_api_aio_SOURCES = test/rados-api/aio.cc test/rados-api/test.cc
+test_rados_api_aio_SOURCES = test/librados/aio.cc test/librados/test.cc
test_rados_api_aio_LDFLAGS = ${AM_LDFLAGS}
test_rados_api_aio_LDADD = librados.la ${UNITTEST_STATIC_LDADD}
test_rados_api_aio_CXXFLAGS = ${AM_CXXFLAGS} ${UNITTEST_CXXFLAGS}
bin_DEBUGPROGRAMS += test_rados_api_aio
-test_rados_api_list_SOURCES = test/rados-api/list.cc test/rados-api/test.cc
+test_rados_api_list_SOURCES = test/librados/list.cc test/librados/test.cc
test_rados_api_list_LDFLAGS = ${AM_LDFLAGS}
test_rados_api_list_LDADD = librados.la ${UNITTEST_STATIC_LDADD}
test_rados_api_list_CXXFLAGS = ${AM_CXXFLAGS} ${UNITTEST_CXXFLAGS}
bin_DEBUGPROGRAMS += test_rados_api_list
-test_rados_api_pool_SOURCES = test/rados-api/pool.cc test/rados-api/test.cc
+test_rados_api_pool_SOURCES = test/librados/pool.cc test/librados/test.cc
test_rados_api_pool_LDFLAGS = ${AM_LDFLAGS}
test_rados_api_pool_LDADD = librados.la ${UNITTEST_STATIC_LDADD}
test_rados_api_pool_CXXFLAGS = ${AM_CXXFLAGS} ${UNITTEST_CXXFLAGS}
bin_DEBUGPROGRAMS += test_rados_api_pool
-test_rados_api_stat_SOURCES = test/rados-api/stat.cc test/rados-api/test.cc
+test_rados_api_stat_SOURCES = test/librados/stat.cc test/librados/test.cc
test_rados_api_stat_LDFLAGS = ${AM_LDFLAGS}
test_rados_api_stat_LDADD = librados.la ${UNITTEST_STATIC_LDADD}
test_rados_api_stat_CXXFLAGS = ${AM_CXXFLAGS} ${UNITTEST_CXXFLAGS}
bin_DEBUGPROGRAMS += test_rados_api_stat
-test_rados_api_watch_notify_SOURCES = test/rados-api/watch_notify.cc test/rados-api/test.cc
+test_rados_api_watch_notify_SOURCES = test/librados/watch_notify.cc test/librados/test.cc
test_rados_api_watch_notify_LDFLAGS = ${AM_LDFLAGS}
test_rados_api_watch_notify_LDADD = librados.la ${UNITTEST_STATIC_LDADD}
test_rados_api_watch_notify_CXXFLAGS = ${AM_CXXFLAGS} ${UNITTEST_CXXFLAGS}
bin_DEBUGPROGRAMS += test_rados_api_watch_notify
-test_rados_api_snapshots_SOURCES = test/rados-api/snapshots.cc test/rados-api/test.cc
+test_rados_api_snapshots_SOURCES = test/librados/snapshots.cc test/librados/test.cc
test_rados_api_snapshots_LDFLAGS = ${AM_LDFLAGS}
test_rados_api_snapshots_LDADD = librados.la ${UNITTEST_STATIC_LDADD}
test_rados_api_snapshots_CXXFLAGS = ${AM_CXXFLAGS} ${UNITTEST_CXXFLAGS}
bin_DEBUGPROGRAMS += test_rados_api_snapshots
-test_rados_api_cls_SOURCES = test/rados-api/cls.cc test/rados-api/test.cc
+test_rados_api_cls_SOURCES = test/librados/cls.cc test/librados/test.cc
test_rados_api_cls_LDFLAGS = ${AM_LDFLAGS}
test_rados_api_cls_LDADD = librados.la ${UNITTEST_STATIC_LDADD}
test_rados_api_cls_CXXFLAGS = ${AM_CXXFLAGS} ${UNITTEST_CXXFLAGS}
bin_DEBUGPROGRAMS += test_rados_api_cls
-test_rados_api_misc_SOURCES = test/rados-api/misc.cc test/rados-api/test.cc
+test_rados_api_misc_SOURCES = test/librados/misc.cc test/librados/test.cc
test_rados_api_misc_LDFLAGS = ${AM_LDFLAGS}
test_rados_api_misc_LDADD = librados.la ${UNITTEST_STATIC_LDADD}
test_rados_api_misc_CXXFLAGS = ${AM_CXXFLAGS} ${UNITTEST_CXXFLAGS}
test_filejournal_CXXFLAGS = ${AM_CXXFLAGS} ${UNITTEST_CXXFLAGS}
bin_DEBUGPROGRAMS += test_filejournal
-test_stress_watch_SOURCES = test/test_stress_watch.cc test/rados-api/test.cc
+test_stress_watch_SOURCES = test/test_stress_watch.cc test/librados/test.cc
test_stress_watch_LDFLAGS = ${AM_LDFLAGS}
test_stress_watch_LDADD = librados.la ${UNITTEST_STATIC_LDADD}
test_stress_watch_CXXFLAGS = ${AM_CXXFLAGS} ${UNITTEST_CXXFLAGS}
test/system/st_rados_watch.h \
test/system/systest_runnable.h \
test/system/systest_settings.h \
- test/rados-api/test.h \
+ test/librados/test.h \
test/unit.h \
os/ObjectMap.h \
os/DBObjectMap.h \
#include "msg/msg_types.h"
#include "include/rados/librados.hpp"
-#include "test/rados-api/test.h"
+#include "test/librados/test.h"
#include "gtest/gtest.h"
using namespace librados;
#include "cls/rbd/cls_rbd_client.h"
#include "gtest/gtest.h"
-#include "test/rados-api/test.h"
+#include "test/librados/test.h"
#include <errno.h>
#include <string>
#include "cls/refcount/cls_refcount_client.h"
#include "gtest/gtest.h"
-#include "test/rados-api/test.h"
+#include "test/librados/test.h"
#include <errno.h>
#include <string>
#include "cls/rgw/cls_rgw_client.h"
#include "gtest/gtest.h"
-#include "test/rados-api/test.h"
+#include "test/librados/test.h"
#include <errno.h>
#include <string>
--- /dev/null
+#include "common/errno.h"
+#include "include/rados/librados.h"
+#include "test/librados/test.h"
+#include "include/types.h"
+
+#include "gtest/gtest.h"
+#include <errno.h>
+#include <semaphore.h>
+#include <sstream>
+#include <string>
+#include <boost/scoped_ptr.hpp>
+#include <utility>
+
+using std::ostringstream;
+using namespace librados;
+using std::pair;
+using std::make_pair;
+
+class AioTestData
+{
+public:
+ AioTestData()
+ : m_cluster(NULL),
+ m_init(false),
+ m_complete(false),
+ m_safe(false)
+ {
+ }
+
+ ~AioTestData()
+ {
+ if (m_init) {
+ rados_ioctx_destroy(m_ioctx);
+ destroy_one_pool(m_pool_name, &m_cluster);
+ sem_destroy(&m_sem);
+ }
+ }
+
+ std::string init()
+ {
+ int ret;
+ if (sem_init(&m_sem, 0, 0)) {
+ int err = errno;
+ sem_destroy(&m_sem);
+ ostringstream oss;
+ oss << "sem_init failed: " << cpp_strerror(err);
+ return oss.str();
+ }
+ m_pool_name = get_temp_pool_name();
+ std::string err = create_one_pool(m_pool_name, &m_cluster);
+ if (!err.empty()) {
+ sem_destroy(&m_sem);
+ ostringstream oss;
+ oss << "create_one_pool(" << m_pool_name << ") failed: error " << err;
+ return oss.str();
+ }
+ ret = rados_ioctx_create(m_cluster, m_pool_name.c_str(), &m_ioctx);
+ if (ret) {
+ sem_destroy(&m_sem);
+ destroy_one_pool(m_pool_name, &m_cluster);
+ ostringstream oss;
+ oss << "rados_ioctx_create failed: error " << ret;
+ return oss.str();
+ }
+ m_init = true;
+ return "";
+ }
+
+ sem_t m_sem;
+ rados_t m_cluster;
+ rados_ioctx_t m_ioctx;
+ std::string m_pool_name;
+ bool m_init;
+ bool m_complete;
+ bool m_safe;
+};
+
+class AioTestDataPP
+{
+public:
+ AioTestDataPP()
+ : m_init(false),
+ m_complete(false),
+ m_safe(false)
+ {
+ }
+
+ ~AioTestDataPP()
+ {
+ if (m_init) {
+ m_ioctx.close();
+ destroy_one_pool_pp(m_pool_name, m_cluster);
+ sem_destroy(&m_sem);
+ }
+ }
+
+ std::string init()
+ {
+ int ret;
+ if (sem_init(&m_sem, 0, 0)) {
+ int err = errno;
+ sem_destroy(&m_sem);
+ ostringstream oss;
+ oss << "sem_init failed: " << cpp_strerror(err);
+ return oss.str();
+ }
+ m_pool_name = get_temp_pool_name();
+ std::string err = create_one_pool_pp(m_pool_name, m_cluster);
+ if (!err.empty()) {
+ sem_destroy(&m_sem);
+ ostringstream oss;
+ oss << "create_one_pool(" << m_pool_name << ") failed: error " << err;
+ return oss.str();
+ }
+ ret = m_cluster.ioctx_create(m_pool_name.c_str(), m_ioctx);
+ if (ret) {
+ sem_destroy(&m_sem);
+ destroy_one_pool_pp(m_pool_name, m_cluster);
+ ostringstream oss;
+ oss << "rados_ioctx_create failed: error " << ret;
+ return oss.str();
+ }
+ m_init = true;
+ return "";
+ }
+
+ sem_t m_sem;
+ Rados m_cluster;
+ IoCtx m_ioctx;
+ std::string m_pool_name;
+ bool m_init;
+ bool m_complete;
+ bool m_safe;
+};
+
+void set_completion_complete(rados_completion_t cb, void *arg)
+{
+ AioTestData *test = (AioTestData*)arg;
+ test->m_complete = true;
+ sem_post(&test->m_sem);
+}
+
+void set_completion_safe(rados_completion_t cb, void *arg)
+{
+ AioTestData *test = (AioTestData*)arg;
+ test->m_safe = true;
+ sem_post(&test->m_sem);
+}
+
+TEST(LibRadosAio, SimpleWrite) {
+ AioTestData test_data;
+ rados_completion_t my_completion;
+ ASSERT_EQ("", test_data.init());
+ ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
+ set_completion_complete, set_completion_safe, &my_completion));
+ char buf[128];
+ memset(buf, 0xcc, sizeof(buf));
+ ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
+ my_completion, buf, sizeof(buf), 0));
+ TestAlarm alarm;
+ sem_wait(&test_data.m_sem);
+ sem_wait(&test_data.m_sem);
+ rados_aio_release(my_completion);
+}
+
+TEST(LibRadosAio, SimpleWritePP) {
+ AioTestDataPP test_data;
+ ASSERT_EQ("", test_data.init());
+ AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
+ (void*)&test_data, set_completion_complete, set_completion_safe);
+ AioCompletion *my_completion_null = NULL;
+ ASSERT_NE(my_completion, my_completion_null);
+ char buf[128];
+ memset(buf, 0xcc, sizeof(buf));
+ bufferlist bl1;
+ bl1.append(buf, sizeof(buf));
+ ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo",
+ my_completion, bl1, sizeof(buf), 0));
+ TestAlarm alarm;
+ sem_wait(&test_data.m_sem);
+ sem_wait(&test_data.m_sem);
+ delete my_completion;
+}
+
+TEST(LibRadosAio, WaitForSafe) {
+ AioTestData test_data;
+ rados_completion_t my_completion;
+ ASSERT_EQ("", test_data.init());
+ ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
+ set_completion_complete, set_completion_safe, &my_completion));
+ char buf[128];
+ memset(buf, 0xcc, sizeof(buf));
+ ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
+ my_completion, buf, sizeof(buf), 0));
+ TestAlarm alarm;
+ ASSERT_EQ(0, rados_aio_wait_for_safe(my_completion));
+ rados_aio_release(my_completion);
+}
+
+TEST(LibRadosAio, WaitForSafePP) {
+ AioTestDataPP test_data;
+ ASSERT_EQ("", test_data.init());
+ AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
+ (void*)&test_data, set_completion_complete, set_completion_safe);
+ AioCompletion *my_completion_null = NULL;
+ ASSERT_NE(my_completion, my_completion_null);
+ char buf[128];
+ memset(buf, 0xcc, sizeof(buf));
+ bufferlist bl1;
+ bl1.append(buf, sizeof(buf));
+ ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo",
+ my_completion, bl1, sizeof(buf), 0));
+ TestAlarm alarm;
+ ASSERT_EQ(0, my_completion->wait_for_safe());
+ delete my_completion;
+}
+
+TEST(LibRadosAio, RoundTrip) {
+ AioTestData test_data;
+ rados_completion_t my_completion;
+ ASSERT_EQ("", test_data.init());
+ ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
+ set_completion_complete, set_completion_safe, &my_completion));
+ char buf[128];
+ memset(buf, 0xcc, sizeof(buf));
+ ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
+ my_completion, buf, sizeof(buf), 0));
+ {
+ TestAlarm alarm;
+ sem_wait(&test_data.m_sem);
+ sem_wait(&test_data.m_sem);
+ }
+ char buf2[128];
+ memset(buf2, 0, sizeof(buf2));
+ rados_completion_t my_completion2;
+ ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
+ set_completion_complete, set_completion_safe, &my_completion2));
+ ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
+ my_completion2, buf2, sizeof(buf2), 0));
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, rados_aio_wait_for_complete(my_completion2));
+ }
+ ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf)));
+ rados_aio_release(my_completion);
+ rados_aio_release(my_completion2);
+}
+
+TEST(LibRadosAio, RoundTrip2) {
+ AioTestData test_data;
+ rados_completion_t my_completion;
+ ASSERT_EQ("", test_data.init());
+ ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
+ set_completion_complete, set_completion_safe, &my_completion));
+ char buf[128];
+ memset(buf, 0xcc, sizeof(buf));
+ ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
+ my_completion, buf, sizeof(buf), 0));
+ {
+ TestAlarm alarm;
+ sem_wait(&test_data.m_sem);
+ sem_wait(&test_data.m_sem);
+ }
+ char buf2[128];
+ memset(buf2, 0, sizeof(buf2));
+ rados_completion_t my_completion2;
+ ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
+ set_completion_complete, set_completion_safe, &my_completion2));
+ ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
+ my_completion2, buf2, sizeof(buf2), 0));
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, rados_aio_wait_for_safe(my_completion2));
+ }
+ ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf)));
+ rados_aio_release(my_completion);
+ rados_aio_release(my_completion2);
+}
+
+TEST(LibRadosAio, RoundTripPP) {
+ AioTestDataPP test_data;
+ ASSERT_EQ("", test_data.init());
+ AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
+ (void*)&test_data, set_completion_complete, set_completion_safe);
+ AioCompletion *my_completion_null = NULL;
+ ASSERT_NE(my_completion, my_completion_null);
+ char buf[128];
+ memset(buf, 0xcc, sizeof(buf));
+ bufferlist bl1;
+ bl1.append(buf, sizeof(buf));
+ ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion,
+ bl1, sizeof(buf), 0));
+ {
+ TestAlarm alarm;
+ sem_wait(&test_data.m_sem);
+ sem_wait(&test_data.m_sem);
+ }
+ bufferlist bl2;
+ AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
+ (void*)&test_data, set_completion_complete, set_completion_safe);
+ ASSERT_NE(my_completion2, my_completion_null);
+ ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo",
+ my_completion2, &bl2, sizeof(buf), 0));
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, my_completion2->wait_for_complete());
+ }
+ ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf)));
+ delete my_completion;
+ delete my_completion2;
+}
+
+TEST(LibRadosAio, RoundTripPP2) {
+ AioTestDataPP test_data;
+ ASSERT_EQ("", test_data.init());
+ AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
+ (void*)&test_data, set_completion_complete, set_completion_safe);
+ AioCompletion *my_completion_null = NULL;
+ ASSERT_NE(my_completion, my_completion_null);
+ char buf[128];
+ memset(buf, 0xcc, sizeof(buf));
+ bufferlist bl1;
+ bl1.append(buf, sizeof(buf));
+ ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion,
+ bl1, sizeof(buf), 0));
+ {
+ TestAlarm alarm;
+ sem_wait(&test_data.m_sem);
+ sem_wait(&test_data.m_sem);
+ }
+ bufferlist bl2;
+ AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
+ (void*)&test_data, set_completion_complete, set_completion_safe);
+ ASSERT_NE(my_completion2, my_completion_null);
+ ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo",
+ my_completion2, &bl2, sizeof(buf), 0));
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, my_completion2->wait_for_safe());
+ }
+ ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf)));
+ delete my_completion;
+ delete my_completion2;
+}
+
+TEST(LibRadosAio, RoundTripAppend) {
+ AioTestData test_data;
+ rados_completion_t my_completion, my_completion2, my_completion3;
+ ASSERT_EQ("", test_data.init());
+ ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
+ set_completion_complete, set_completion_safe, &my_completion));
+ char buf[128];
+ memset(buf, 0xcc, sizeof(buf));
+ ASSERT_EQ(0, rados_aio_append(test_data.m_ioctx, "foo",
+ my_completion, buf, sizeof(buf)));
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, rados_aio_wait_for_complete(my_completion));
+ }
+ char buf2[128];
+ memset(buf2, 0xdd, sizeof(buf2));
+ ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
+ set_completion_complete, set_completion_safe, &my_completion2));
+ ASSERT_EQ(0, rados_aio_append(test_data.m_ioctx, "foo",
+ my_completion2, buf2, sizeof(buf)));
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, rados_aio_wait_for_complete(my_completion2));
+ }
+ char buf3[sizeof(buf) + sizeof(buf2)];
+ memset(buf3, 0, sizeof(buf3));
+ ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
+ set_completion_complete, set_completion_safe, &my_completion3));
+ ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
+ my_completion3, buf3, sizeof(buf3), 0));
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, rados_aio_wait_for_complete(my_completion3));
+ }
+ ASSERT_EQ(0, memcmp(buf3, buf, sizeof(buf)));
+ ASSERT_EQ(0, memcmp(buf3 + sizeof(buf), buf2, sizeof(buf2)));
+ rados_aio_release(my_completion);
+ rados_aio_release(my_completion2);
+ rados_aio_release(my_completion3);
+}
+
+TEST(LibRadosAio, RoundTripAppendPP) {
+ AioTestDataPP test_data;
+ ASSERT_EQ("", test_data.init());
+ AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
+ (void*)&test_data, set_completion_complete, set_completion_safe);
+ AioCompletion *my_completion_null = NULL;
+ ASSERT_NE(my_completion, my_completion_null);
+ char buf[128];
+ memset(buf, 0xcc, sizeof(buf));
+ bufferlist bl1;
+ bl1.append(buf, sizeof(buf));
+ ASSERT_EQ(0, test_data.m_ioctx.aio_append("foo", my_completion,
+ bl1, sizeof(buf)));
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, my_completion->wait_for_complete());
+ }
+ char buf2[128];
+ memset(buf2, 0xdd, sizeof(buf2));
+ bufferlist bl2;
+ bl2.append(buf2, sizeof(buf2));
+ AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
+ (void*)&test_data, set_completion_complete, set_completion_safe);
+ ASSERT_NE(my_completion2, my_completion_null);
+ ASSERT_EQ(0, test_data.m_ioctx.aio_append("foo", my_completion2,
+ bl2, sizeof(buf2)));
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, my_completion2->wait_for_complete());
+ }
+ bufferlist bl3;
+ AioCompletion *my_completion3 = test_data.m_cluster.aio_create_completion(
+ (void*)&test_data, set_completion_complete, set_completion_safe);
+ ASSERT_NE(my_completion3, my_completion_null);
+ ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo",
+ my_completion3, &bl3, 2 * sizeof(buf), 0));
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, my_completion3->wait_for_complete());
+ }
+ ASSERT_EQ(0, memcmp(bl3.c_str(), buf, sizeof(buf)));
+ ASSERT_EQ(0, memcmp(bl3.c_str() + sizeof(buf), buf2, sizeof(buf2)));
+ delete my_completion;
+ delete my_completion2;
+ delete my_completion3;
+}
+
+TEST(LibRadosAio, IsComplete) {
+ AioTestData test_data;
+ rados_completion_t my_completion;
+ ASSERT_EQ("", test_data.init());
+ ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
+ set_completion_complete, set_completion_safe, &my_completion));
+ char buf[128];
+ memset(buf, 0xcc, sizeof(buf));
+ ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
+ my_completion, buf, sizeof(buf), 0));
+ {
+ TestAlarm alarm;
+ sem_wait(&test_data.m_sem);
+ sem_wait(&test_data.m_sem);
+ }
+ char buf2[128];
+ memset(buf2, 0, sizeof(buf2));
+ rados_completion_t my_completion2;
+ ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
+ set_completion_complete, set_completion_safe, &my_completion2));
+ ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
+ my_completion2, buf2, sizeof(buf2), 0));
+ {
+ TestAlarm alarm;
+
+ // Busy-wait until the AIO completes.
+ // Normally we wouldn't do this, but we want to test rados_aio_is_complete.
+ while (true) {
+ int is_complete = rados_aio_is_complete(my_completion2);
+ if (is_complete)
+ break;
+ }
+ }
+ ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf)));
+ rados_aio_release(my_completion);
+ rados_aio_release(my_completion2);
+}
+
+TEST(LibRadosAio, IsCompletePP) {
+ AioTestDataPP test_data;
+ ASSERT_EQ("", test_data.init());
+ AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
+ (void*)&test_data, set_completion_complete, set_completion_safe);
+ AioCompletion *my_completion_null = NULL;
+ ASSERT_NE(my_completion, my_completion_null);
+ char buf[128];
+ memset(buf, 0xcc, sizeof(buf));
+ bufferlist bl1;
+ bl1.append(buf, sizeof(buf));
+ ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion,
+ bl1, sizeof(buf), 0));
+ {
+ TestAlarm alarm;
+ sem_wait(&test_data.m_sem);
+ sem_wait(&test_data.m_sem);
+ }
+ bufferlist bl2;
+ AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
+ (void*)&test_data, set_completion_complete, set_completion_safe);
+ ASSERT_NE(my_completion2, my_completion_null);
+ ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2,
+ &bl2, sizeof(buf), 0));
+ {
+ TestAlarm alarm;
+
+ // Busy-wait until the AIO completes.
+ // Normally we wouldn't do this, but we want to test rados_aio_is_complete.
+ while (true) {
+ int is_complete = my_completion2->is_complete();
+ if (is_complete)
+ break;
+ }
+ }
+ ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf)));
+ delete my_completion;
+ delete my_completion2;
+}
+
+TEST(LibRadosAio, IsSafe) {
+ AioTestData test_data;
+ rados_completion_t my_completion;
+ ASSERT_EQ("", test_data.init());
+ ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
+ set_completion_complete, set_completion_safe, &my_completion));
+ char buf[128];
+ memset(buf, 0xcc, sizeof(buf));
+ ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
+ my_completion, buf, sizeof(buf), 0));
+ {
+ TestAlarm alarm;
+
+ // Busy-wait until the AIO completes.
+ // Normally we wouldn't do this, but we want to test rados_aio_is_safe.
+ while (true) {
+ int is_safe = rados_aio_is_safe(my_completion);
+ if (is_safe)
+ break;
+ }
+ }
+ char buf2[128];
+ memset(buf2, 0, sizeof(buf2));
+ rados_completion_t my_completion2;
+ ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
+ set_completion_complete, set_completion_safe, &my_completion2));
+ ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
+ my_completion2, buf2, sizeof(buf2), 0));
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, rados_aio_wait_for_complete(my_completion2));
+ }
+ ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf)));
+ rados_aio_release(my_completion);
+ rados_aio_release(my_completion2);
+}
+
+TEST(LibRadosAio, IsSafePP) {
+ AioTestDataPP test_data;
+ ASSERT_EQ("", test_data.init());
+ AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
+ (void*)&test_data, set_completion_complete, set_completion_safe);
+ AioCompletion *my_completion_null = NULL;
+ ASSERT_NE(my_completion, my_completion_null);
+ char buf[128];
+ memset(buf, 0xcc, sizeof(buf));
+ bufferlist bl1;
+ bl1.append(buf, sizeof(buf));
+ ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion,
+ bl1, sizeof(buf), 0));
+ {
+ TestAlarm alarm;
+
+ // Busy-wait until the AIO completes.
+ // Normally we wouldn't do this, but we want to test rados_aio_is_safe.
+ while (true) {
+ int is_safe = my_completion->is_safe();
+ if (is_safe)
+ break;
+ }
+ }
+ AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
+ (void*)&test_data, set_completion_complete, set_completion_safe);
+ bufferlist bl2;
+ ASSERT_NE(my_completion2, my_completion_null);
+ ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2,
+ &bl2, sizeof(buf), 0));
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, my_completion2->wait_for_complete());
+ }
+ ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf)));
+ delete my_completion;
+ delete my_completion2;
+}
+
+TEST(LibRadosAio, ReturnValue) {
+ AioTestData test_data;
+ rados_completion_t my_completion;
+ ASSERT_EQ("", test_data.init());
+ ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
+ set_completion_complete, set_completion_safe, &my_completion));
+ char buf[128];
+ memset(buf, 0, sizeof(buf));
+ ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "nonexistent",
+ my_completion, buf, sizeof(buf), 0));
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, rados_aio_wait_for_complete(my_completion));
+ }
+ ASSERT_EQ(-ENOENT, rados_aio_get_return_value(my_completion));
+ rados_aio_release(my_completion);
+}
+
+TEST(LibRadosAio, ReturnValuePP) {
+ AioTestDataPP test_data;
+ ASSERT_EQ("", test_data.init());
+ AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
+ (void*)&test_data, set_completion_complete, set_completion_safe);
+ AioCompletion *my_completion_null = NULL;
+ ASSERT_NE(my_completion, my_completion_null);
+ bufferlist bl1;
+ ASSERT_EQ(0, test_data.m_ioctx.aio_read("nonexistent",
+ my_completion, &bl1, 128, 0));
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, my_completion->wait_for_complete());
+ }
+ ASSERT_EQ(-ENOENT, my_completion->get_return_value());
+ delete my_completion;
+}
+
+TEST(LibRadosAio, Flush) {
+ AioTestData test_data;
+ rados_completion_t my_completion;
+ ASSERT_EQ("", test_data.init());
+ ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
+ set_completion_complete, set_completion_safe, &my_completion));
+ char buf[128];
+ memset(buf, 0xee, sizeof(buf));
+ ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
+ my_completion, buf, sizeof(buf), 0));
+ ASSERT_EQ(0, rados_aio_flush(test_data.m_ioctx));
+ char buf2[128];
+ memset(buf2, 0, sizeof(buf2));
+ rados_completion_t my_completion2;
+ ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
+ set_completion_complete, set_completion_safe, &my_completion2));
+ ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
+ my_completion2, buf2, sizeof(buf2), 0));
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, rados_aio_wait_for_complete(my_completion2));
+ }
+ ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf)));
+ rados_aio_release(my_completion);
+ rados_aio_release(my_completion2);
+}
+
+TEST(LibRadosAio, FlushPP) {
+ AioTestDataPP test_data;
+ ASSERT_EQ("", test_data.init());
+ AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
+ (void*)&test_data, set_completion_complete, set_completion_safe);
+ AioCompletion *my_completion_null = NULL;
+ ASSERT_NE(my_completion, my_completion_null);
+ char buf[128];
+ memset(buf, 0xee, sizeof(buf));
+ bufferlist bl1;
+ bl1.append(buf, sizeof(buf));
+ ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion,
+ bl1, sizeof(buf), 0));
+ ASSERT_EQ(0, test_data.m_ioctx.aio_flush());
+ bufferlist bl2;
+ AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
+ (void*)&test_data, set_completion_complete, set_completion_safe);
+ ASSERT_NE(my_completion2, my_completion_null);
+ ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2,
+ &bl2, sizeof(buf), 0));
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, my_completion2->wait_for_complete());
+ }
+ ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf)));
+ delete my_completion;
+ delete my_completion2;
+}
+
+TEST(LibRadosAio, RoundTripWriteFull) {
+ AioTestData test_data;
+ rados_completion_t my_completion, my_completion2, my_completion3;
+ ASSERT_EQ("", test_data.init());
+ ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
+ set_completion_complete, set_completion_safe, &my_completion));
+ char buf[128];
+ memset(buf, 0xcc, sizeof(buf));
+ ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
+ my_completion, buf, sizeof(buf), 0));
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, rados_aio_wait_for_complete(my_completion));
+ }
+ char buf2[64];
+ memset(buf2, 0xdd, sizeof(buf2));
+ ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
+ set_completion_complete, set_completion_safe, &my_completion2));
+ ASSERT_EQ(0, rados_aio_write_full(test_data.m_ioctx, "foo",
+ my_completion2, buf2, sizeof(buf2)));
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, rados_aio_wait_for_complete(my_completion2));
+ }
+ char buf3[sizeof(buf) + sizeof(buf2)];
+ memset(buf3, 0, sizeof(buf3));
+ ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
+ set_completion_complete, set_completion_safe, &my_completion3));
+ ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
+ my_completion3, buf3, sizeof(buf3), 0));
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, rados_aio_wait_for_complete(my_completion3));
+ }
+ ASSERT_EQ(0, memcmp(buf3, buf2, sizeof(buf2)));
+ rados_aio_release(my_completion);
+ rados_aio_release(my_completion2);
+ rados_aio_release(my_completion3);
+}
+
+TEST(LibRadosAio, RoundTripWriteFullPP) {
+ AioTestDataPP test_data;
+ ASSERT_EQ("", test_data.init());
+ AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
+ (void*)&test_data, set_completion_complete, set_completion_safe);
+ AioCompletion *my_completion_null = NULL;
+ ASSERT_NE(my_completion, my_completion_null);
+ char buf[128];
+ memset(buf, 0xcc, sizeof(buf));
+ bufferlist bl1;
+ bl1.append(buf, sizeof(buf));
+ ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion,
+ bl1, sizeof(buf), 0));
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, my_completion->wait_for_complete());
+ }
+ char buf2[64];
+ memset(buf2, 0xdd, sizeof(buf2));
+ bufferlist bl2;
+ bl2.append(buf2, sizeof(buf2));
+ AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
+ (void*)&test_data, set_completion_complete, set_completion_safe);
+ ASSERT_NE(my_completion2, my_completion_null);
+ ASSERT_EQ(0, test_data.m_ioctx.aio_write_full("foo", my_completion2, bl2));
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, my_completion2->wait_for_complete());
+ }
+ bufferlist bl3;
+ AioCompletion *my_completion3 = test_data.m_cluster.aio_create_completion(
+ (void*)&test_data, set_completion_complete, set_completion_safe);
+ ASSERT_NE(my_completion3, my_completion_null);
+ ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion3,
+ &bl3, sizeof(buf), 0));
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, my_completion3->wait_for_complete());
+ }
+ ASSERT_EQ(0, memcmp(bl3.c_str(), buf2, sizeof(buf2)));
+ delete my_completion;
+ delete my_completion2;
+ delete my_completion3;
+}
+
+using std::string;
+using std::map;
+using std::set;
+
+TEST(LibRadosAio, OmapPP) {
+ Rados cluster;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ IoCtx ioctx;
+ cluster.ioctx_create(pool_name.c_str(), ioctx);
+
+ string header_str = "baz";
+ bufferptr bp(header_str.c_str(), header_str.size() + 1);
+ bufferlist header_to_set;
+ header_to_set.push_back(bp);
+ map<string, bufferlist> to_set;
+ {
+ boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0, 0));
+ ObjectWriteOperation op;
+ string val = "bar";
+ to_set["foo"] = header_to_set;
+ to_set["foo2"] = header_to_set;
+ to_set["qfoo3"] = header_to_set;
+ op.omap_set(to_set);
+
+ op.omap_set_header(header_to_set);
+
+ ioctx.aio_operate("test_obj", my_completion.get(), &op);
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, my_completion->wait_for_complete());
+ }
+ }
+
+ {
+ boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0, 0));
+ ObjectReadOperation op;
+ map<string, pair<bufferlist, int> > assertions;
+ bufferlist val;
+ val.append(string("bar"));
+ assertions["foo"] = pair<bufferlist, int>(val, CEPH_OSD_CMPXATTR_OP_EQ);
+
+ int r;
+ op.omap_cmp(assertions, &r);
+
+ ioctx.aio_operate("test_obj", my_completion.get(), &op, 0);
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, my_completion->wait_for_complete());
+ }
+ ASSERT_EQ(0, r);
+ }
+
+ {
+ boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0, 0));
+ ObjectReadOperation op;
+
+ set<string> set_got;
+ map<string, bufferlist> map_got;
+
+ set<string> to_get;
+ map<string, bufferlist> got3;
+
+ map<string, bufferlist> got4;
+
+ bufferlist header;
+
+ op.omap_get_keys("", 1, &set_got, 0);
+ op.omap_get_vals("foo", 1, &map_got, 0);
+
+ to_get.insert("foo");
+ to_get.insert("qfoo3");
+ op.omap_get_vals_by_keys(to_get, &got3, 0);
+
+ op.omap_get_header(&header, 0);
+
+ op.omap_get_vals("foo2", "q", 1, &got4, 0);
+
+ ioctx.aio_operate("test_obj", my_completion.get(), &op, 0);
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, my_completion->wait_for_complete());
+ }
+
+ ASSERT_EQ(header.length(), header_to_set.length());
+ ASSERT_EQ(set_got.size(), (unsigned)1);
+ ASSERT_EQ(*set_got.begin(), "foo");
+ ASSERT_EQ(map_got.size(), (unsigned)1);
+ ASSERT_EQ(map_got.begin()->first, "foo2");
+ ASSERT_EQ(got3.size(), (unsigned)2);
+ ASSERT_EQ(got3.begin()->first, "foo");
+ ASSERT_EQ(got3.rbegin()->first, "qfoo3");
+ ASSERT_EQ(got4.size(), (unsigned)1);
+ ASSERT_EQ(got4.begin()->first, "qfoo3");
+ }
+
+ {
+ boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0, 0));
+ ObjectWriteOperation op;
+ set<string> to_remove;
+ to_remove.insert("foo2");
+ op.omap_rm_keys(to_remove);
+ ioctx.aio_operate("test_obj", my_completion.get(), &op);
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, my_completion->wait_for_complete());
+ }
+ }
+
+ {
+ boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0, 0));
+ ObjectReadOperation op;
+
+ set<string> set_got;
+ op.omap_get_keys("", -1, &set_got, 0);
+ ioctx.aio_operate("test_obj", my_completion.get(), &op, 0);
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, my_completion->wait_for_complete());
+ }
+ ASSERT_EQ(set_got.size(), (unsigned)2);
+ }
+
+ {
+ boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0, 0));
+ ObjectWriteOperation op;
+ op.omap_clear();
+ ioctx.aio_operate("test_obj", my_completion.get(), &op);
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, my_completion->wait_for_complete());
+ }
+ }
+
+ {
+ boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0, 0));
+ ObjectReadOperation op;
+
+ set<string> set_got;
+ op.omap_get_keys("", -1, &set_got, 0);
+ ioctx.aio_operate("test_obj", my_completion.get(), &op, 0);
+ {
+ TestAlarm alarm;
+ ASSERT_EQ(0, my_completion->wait_for_complete());
+ }
+ ASSERT_EQ(set_got.size(), (unsigned)0);
+ }
+
+ ioctx.remove("test_obj");
+}
--- /dev/null
+#include "include/rados/librados.h"
+#include "include/rados/librados.hpp"
+#include "test/librados/test.h"
+
+#include "gtest/gtest.h"
+#include <errno.h>
+#include <map>
+#include <sstream>
+#include <string>
+
+using namespace librados;
+using ceph::buffer;
+using std::map;
+using std::ostringstream;
+using std::string;
+
+TEST(LibRadosCls, DNE) {
+ Rados cluster;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ IoCtx ioctx;
+ cluster.ioctx_create(pool_name.c_str(), ioctx);
+
+ // create an object
+ string oid = "foo";
+ bufferlist bl;
+ ASSERT_EQ(0, ioctx.write(oid, bl, bl.length(), 0));
+
+ // call a bogus class
+ ASSERT_EQ(-EOPNOTSUPP, ioctx.exec(oid, "doesnotexistasdfasdf", "method", bl, bl));
+
+ // call a bogus method on existent class
+ ASSERT_EQ(-EOPNOTSUPP, ioctx.exec(oid, "lock", "doesnotexistasdfasdfasdf", bl, bl));
+
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
--- /dev/null
+#include "include/rados/librados.h"
+#include "include/rados/librados.hpp"
+#include "test/librados/test.h"
+
+#include <errno.h>
+#include "gtest/gtest.h"
+
+using namespace librados;
+using std::string;
+
+TEST(LibRadosIo, SimpleWrite) {
+ char buf[128];
+ rados_t cluster;
+ rados_ioctx_t ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
+ memset(buf, 0xcc, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
+ rados_ioctx_destroy(ioctx);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosIo, SimpleWritePP) {
+ char buf[128];
+ std::string pool_name = get_temp_pool_name();
+ Rados cluster;
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ IoCtx ioctx;
+ cluster.ioctx_create(pool_name.c_str(), ioctx);
+ memset(buf, 0xcc, sizeof(buf));
+ bufferlist bl;
+ bl.append(buf, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl, sizeof(buf), 0));
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
+
+TEST(LibRadosIo, RoundTrip) {
+ char buf[128];
+ char buf2[128];
+ rados_t cluster;
+ rados_ioctx_t ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
+ memset(buf, 0xcc, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
+ memset(buf2, 0, sizeof(buf2));
+ ASSERT_EQ((int)sizeof(buf2), rados_read(ioctx, "foo", buf2, sizeof(buf2), 0));
+ ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf)));
+ rados_ioctx_destroy(ioctx);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosIo, RoundTripPP) {
+ char buf[128];
+ char buf2[128];
+ Rados cluster;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ IoCtx ioctx;
+ cluster.ioctx_create(pool_name.c_str(), ioctx);
+ memset(buf, 0xcc, sizeof(buf));
+ bufferlist bl;
+ bl.append(buf, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl, sizeof(buf), 0));
+ bufferlist cl;
+ ASSERT_EQ((int)sizeof(buf2), ioctx.read("foo", cl, sizeof(buf), 0));
+ ASSERT_EQ(0, memcmp(buf, cl.c_str(), sizeof(buf)));
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
+
+TEST(LibRadosIo, OverlappingWriteRoundTrip) {
+ char buf[128];
+ char buf2[64];
+ char buf3[128];
+ rados_t cluster;
+ rados_ioctx_t ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
+ memset(buf, 0xcc, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
+ memset(buf2, 0xdd, sizeof(buf2));
+ ASSERT_EQ((int)sizeof(buf2), rados_write(ioctx, "foo", buf2, sizeof(buf2), 0));
+ memset(buf3, 0xdd, sizeof(buf3));
+ ASSERT_EQ((int)sizeof(buf3), rados_read(ioctx, "foo", buf3, sizeof(buf3), 0));
+ ASSERT_EQ(0, memcmp(buf3, buf2, sizeof(buf2)));
+ ASSERT_EQ(0, memcmp(buf3 + sizeof(buf2), buf, sizeof(buf) - sizeof(buf2)));
+ rados_ioctx_destroy(ioctx);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosIo, OverlappingWriteRoundTripPP) {
+ char buf[128];
+ char buf2[64];
+ Rados cluster;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ IoCtx ioctx;
+ cluster.ioctx_create(pool_name.c_str(), ioctx);
+ memset(buf, 0xcc, sizeof(buf));
+ bufferlist bl1;
+ bl1.append(buf, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl1, sizeof(buf), 0));
+ memset(buf2, 0xdd, sizeof(buf2));
+ bufferlist bl2;
+ bl2.append(buf2, sizeof(buf2));
+ ASSERT_EQ((int)sizeof(buf2), ioctx.write("foo", bl2, sizeof(buf2), 0));
+ bufferlist bl3;
+ ASSERT_EQ((int)sizeof(buf), ioctx.read("foo", bl3, sizeof(buf), 0));
+ ASSERT_EQ(0, memcmp(bl3.c_str(), buf2, sizeof(buf2)));
+ ASSERT_EQ(0, memcmp(bl3.c_str() + sizeof(buf2), buf, sizeof(buf) - sizeof(buf2)));
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
+
+TEST(LibRadosIo, WriteFullRoundTrip) {
+ char buf[128];
+ char buf2[64];
+ char buf3[128];
+ rados_t cluster;
+ rados_ioctx_t ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
+ memset(buf, 0xcc, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
+ memset(buf2, 0xdd, sizeof(buf2));
+ ASSERT_EQ(0, rados_write_full(ioctx, "foo", buf2, sizeof(buf2)));
+ memset(buf3, 0xdd, sizeof(buf3));
+ ASSERT_EQ((int)sizeof(buf2), rados_read(ioctx, "foo", buf3, sizeof(buf3), 0));
+ ASSERT_EQ(0, memcmp(buf2, buf2, sizeof(buf2)));
+ rados_ioctx_destroy(ioctx);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosIo, WriteFullRoundTripPP) {
+ char buf[128];
+ char buf2[64];
+ Rados cluster;
+ IoCtx ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ cluster.ioctx_create(pool_name.c_str(), ioctx);
+ memset(buf, 0xcc, sizeof(buf));
+ bufferlist bl1;
+ bl1.append(buf, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl1, sizeof(buf), 0));
+ memset(buf2, 0xdd, sizeof(buf2));
+ bufferlist bl2;
+ bl2.append(buf2, sizeof(buf2));
+ ASSERT_EQ(0, ioctx.write_full("foo", bl2));
+ bufferlist bl3;
+ ASSERT_EQ((int)sizeof(buf2), ioctx.read("foo", bl3, sizeof(buf), 0));
+ ASSERT_EQ(0, memcmp(bl3.c_str(), buf2, sizeof(buf2)));
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
+
+TEST(LibRadosIo, AppendRoundTrip) {
+ char buf[64];
+ char buf2[64];
+ char buf3[sizeof(buf) + sizeof(buf2)];
+ rados_t cluster;
+ rados_ioctx_t ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
+ memset(buf, 0xde, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), rados_append(ioctx, "foo", buf, sizeof(buf)));
+ memset(buf2, 0xad, sizeof(buf2));
+ ASSERT_EQ((int)sizeof(buf2), rados_append(ioctx, "foo", buf2, sizeof(buf2)));
+ memset(buf3, 0, sizeof(buf3));
+ ASSERT_EQ((int)sizeof(buf3), rados_read(ioctx, "foo", buf3, sizeof(buf3), 0));
+ ASSERT_EQ(0, memcmp(buf3, buf, sizeof(buf)));
+ ASSERT_EQ(0, memcmp(buf3 + sizeof(buf), buf2, sizeof(buf2)));
+ rados_ioctx_destroy(ioctx);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosIo, AppendRoundTripPP) {
+ char buf[64];
+ char buf2[64];
+ Rados cluster;
+ IoCtx ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ cluster.ioctx_create(pool_name.c_str(), ioctx);
+ memset(buf, 0xde, sizeof(buf));
+ bufferlist bl1;
+ bl1.append(buf, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), ioctx.append("foo", bl1, sizeof(buf)));
+ memset(buf2, 0xad, sizeof(buf2));
+ bufferlist bl2;
+ bl2.append(buf2, sizeof(buf2));
+ ASSERT_EQ((int)sizeof(buf2), ioctx.append("foo", bl2, sizeof(buf2)));
+ bufferlist bl3;
+ ASSERT_EQ((int)(sizeof(buf) + sizeof(buf2)),
+ ioctx.read("foo", bl3, (sizeof(buf) + sizeof(buf2)), 0));
+ const char *bl3_str = bl3.c_str();
+ ASSERT_EQ(0, memcmp(bl3_str, buf, sizeof(buf)));
+ ASSERT_EQ(0, memcmp(bl3_str + sizeof(buf), buf2, sizeof(buf2)));
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
+
+TEST(LibRadosIo, TruncTest) {
+ char buf[128];
+ char buf2[sizeof(buf)];
+ rados_t cluster;
+ rados_ioctx_t ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
+ memset(buf, 0xaa, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), rados_append(ioctx, "foo", buf, sizeof(buf)));
+ ASSERT_EQ(0, rados_trunc(ioctx, "foo", sizeof(buf) / 2));
+ memset(buf2, 0, sizeof(buf2));
+ ASSERT_EQ((int)(sizeof(buf)/2), rados_read(ioctx, "foo", buf2, sizeof(buf2), 0));
+ ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf)/2));
+ rados_ioctx_destroy(ioctx);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosIo, TruncTestPP) {
+ char buf[128];
+ Rados cluster;
+ IoCtx ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ cluster.ioctx_create(pool_name.c_str(), ioctx);
+ memset(buf, 0xaa, sizeof(buf));
+ bufferlist bl;
+ bl.append(buf, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), ioctx.append("foo", bl, sizeof(buf)));
+ ASSERT_EQ(0, ioctx.trunc("foo", sizeof(buf) / 2));
+ bufferlist bl2;
+ ASSERT_EQ((int)(sizeof(buf)/2), ioctx.read("foo", bl2, sizeof(buf), 0));
+ ASSERT_EQ(0, memcmp(bl2.c_str(), buf, sizeof(buf)/2));
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
+
+TEST(LibRadosIo, RemoveTest) {
+ char buf[128];
+ char buf2[sizeof(buf)];
+ rados_t cluster;
+ rados_ioctx_t ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
+ memset(buf, 0xaa, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), rados_append(ioctx, "foo", buf, sizeof(buf)));
+ ASSERT_EQ(0, rados_remove(ioctx, "foo"));
+ memset(buf2, 0, sizeof(buf2));
+ ASSERT_EQ(-ENOENT, rados_read(ioctx, "foo", buf2, sizeof(buf2), 0));
+ rados_ioctx_destroy(ioctx);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosIo, RemoveTestPP) {
+ char buf[128];
+ Rados cluster;
+ IoCtx ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ cluster.ioctx_create(pool_name.c_str(), ioctx);
+ memset(buf, 0xaa, sizeof(buf));
+ bufferlist bl1;
+ bl1.append(buf, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), ioctx.append("foo", bl1, sizeof(buf)));
+ ASSERT_EQ(0, ioctx.remove("foo"));
+ bufferlist bl2;
+ ASSERT_EQ(-ENOENT, ioctx.read("foo", bl2, sizeof(buf), 0));
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
+
+TEST(LibRadosIo, XattrsRoundTrip) {
+ char buf[128];
+ char attr1[] = "attr1";
+ char attr1_buf[] = "foo bar baz";
+ rados_t cluster;
+ rados_ioctx_t ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
+ memset(buf, 0xaa, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), rados_append(ioctx, "foo", buf, sizeof(buf)));
+ ASSERT_EQ(-ENODATA, rados_getxattr(ioctx, "foo", attr1, buf, sizeof(buf)));
+ ASSERT_EQ(0, rados_setxattr(ioctx, "foo", attr1, attr1_buf, sizeof(attr1_buf)));
+ ASSERT_EQ((int)sizeof(attr1_buf),
+ rados_getxattr(ioctx, "foo", attr1, buf, sizeof(buf)));
+ ASSERT_EQ(0, memcmp(attr1_buf, buf, sizeof(attr1_buf)));
+ rados_ioctx_destroy(ioctx);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosIo, XattrsRoundTripPP) {
+ char buf[128];
+ char attr1[] = "attr1";
+ char attr1_buf[] = "foo bar baz";
+ Rados cluster;
+ IoCtx ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ cluster.ioctx_create(pool_name.c_str(), ioctx);
+ memset(buf, 0xaa, sizeof(buf));
+ bufferlist bl1;
+ bl1.append(buf, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), ioctx.append("foo", bl1, sizeof(buf)));
+ bufferlist bl2;
+ ASSERT_EQ(-ENODATA, ioctx.getxattr("foo", attr1, bl2));
+ bufferlist bl3;
+ bl3.append(attr1_buf, sizeof(attr1_buf));
+ ASSERT_EQ(0, ioctx.setxattr("foo", attr1, bl3));
+ bufferlist bl4;
+ ASSERT_EQ((int)sizeof(attr1_buf),
+ ioctx.getxattr("foo", attr1, bl4));
+ ASSERT_EQ(0, memcmp(bl4.c_str(), attr1_buf, sizeof(attr1_buf)));
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
+
+TEST(LibRadosIo, RmXattr) {
+ char buf[128];
+ char attr1[] = "attr1";
+ char attr1_buf[] = "foo bar baz";
+ rados_t cluster;
+ rados_ioctx_t ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
+ memset(buf, 0xaa, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), rados_append(ioctx, "foo", buf, sizeof(buf)));
+ ASSERT_EQ(0,
+ rados_setxattr(ioctx, "foo", attr1, attr1_buf, sizeof(attr1_buf)));
+ ASSERT_EQ(0, rados_rmxattr(ioctx, "foo", attr1));
+ ASSERT_EQ(-ENODATA, rados_getxattr(ioctx, "foo", attr1, buf, sizeof(buf)));
+ rados_ioctx_destroy(ioctx);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosIo, RmXattrPP) {
+ char buf[128];
+ char attr1[] = "attr1";
+ char attr1_buf[] = "foo bar baz";
+ Rados cluster;
+ IoCtx ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ cluster.ioctx_create(pool_name.c_str(), ioctx);
+ memset(buf, 0xaa, sizeof(buf));
+ bufferlist bl1;
+ bl1.append(buf, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), ioctx.append("foo", bl1, sizeof(buf)));
+ bufferlist bl2;
+ bl2.append(attr1_buf, sizeof(attr1_buf));
+ ASSERT_EQ(0, ioctx.setxattr("foo", attr1, bl2));
+ ASSERT_EQ(0, ioctx.rmxattr("foo", attr1));
+ bufferlist bl3;
+ ASSERT_EQ(-ENODATA, ioctx.getxattr("foo", attr1, bl3));
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
+
+TEST(LibRadosIo, XattrIter) {
+ char buf[128];
+ char attr1[] = "attr1";
+ char attr1_buf[] = "foo bar baz";
+ char attr2[] = "attr2";
+ char attr2_buf[256];
+ for (size_t j = 0; j < sizeof(attr2_buf); ++j) {
+ attr2_buf[j] = j % 0xff;
+ }
+ rados_t cluster;
+ rados_ioctx_t ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
+ memset(buf, 0xaa, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), rados_append(ioctx, "foo", buf, sizeof(buf)));
+ ASSERT_EQ(0, rados_setxattr(ioctx, "foo", attr1, attr1_buf, sizeof(attr1_buf)));
+ ASSERT_EQ(0, rados_setxattr(ioctx, "foo", attr2, attr2_buf, sizeof(attr2_buf)));
+ rados_xattrs_iter_t iter;
+ ASSERT_EQ(0, rados_getxattrs(ioctx, "foo", &iter));
+ int num_seen = 0;
+ while (true) {
+ const char *name;
+ const char *val;
+ size_t len;
+ ASSERT_EQ(0, rados_getxattrs_next(iter, &name, &val, &len));
+ if (name == NULL) {
+ break;
+ }
+ ASSERT_LT(num_seen, 2);
+ if ((strcmp(name, attr1) == 0) && (memcmp(val, attr1_buf, len) == 0)) {
+ num_seen++;
+ continue;
+ }
+ else if ((strcmp(name, attr2) == 0) && (memcmp(val, attr2_buf, len) == 0)) {
+ num_seen++;
+ continue;
+ }
+ else {
+ ASSERT_EQ(0, 1);
+ }
+ }
+ rados_getxattrs_end(iter);
+ rados_ioctx_destroy(ioctx);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosIo, XattrListPP) {
+ char buf[128];
+ char attr1[] = "attr1";
+ char attr1_buf[] = "foo bar baz";
+ char attr2[] = "attr2";
+ char attr2_buf[256];
+ for (size_t j = 0; j < sizeof(attr2_buf); ++j) {
+ attr2_buf[j] = j % 0xff;
+ }
+ Rados cluster;
+ IoCtx ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ cluster.ioctx_create(pool_name.c_str(), ioctx);
+ memset(buf, 0xaa, sizeof(buf));
+ bufferlist bl1;
+ bl1.append(buf, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), ioctx.append("foo", bl1, sizeof(buf)));
+ bufferlist bl2;
+ bl2.append(attr1_buf, sizeof(attr1_buf));
+ ASSERT_EQ(0, ioctx.setxattr("foo", attr1, bl2));
+ bufferlist bl3;
+ bl3.append(attr2_buf, sizeof(attr2_buf));
+ ASSERT_EQ(0, ioctx.setxattr("foo", attr2, bl3));
+ std::map<std::string, bufferlist> attrset;
+ ASSERT_EQ(0, ioctx.getxattrs("foo", attrset));
+ for (std::map<std::string, bufferlist>::iterator i = attrset.begin();
+ i != attrset.end(); ++i) {
+ if (i->first == string(attr1)) {
+ ASSERT_EQ(0, memcmp(i->second.c_str(), attr1_buf, sizeof(attr1_buf)));
+ }
+ else if (i->first == string(attr2)) {
+ ASSERT_EQ(0, memcmp(i->second.c_str(), attr2_buf, sizeof(attr2_buf)));
+ }
+ else {
+ ASSERT_EQ(0, 1);
+ }
+ }
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
--- /dev/null
+#include "include/rados/librados.h"
+#include "include/rados/librados.hpp"
+#include "test/librados/test.h"
+
+#include "gtest/gtest.h"
+#include <errno.h>
+#include <string>
+
+using namespace librados;
+
+TEST(LibRadosList, ListObjects) {
+ char buf[128];
+ rados_t cluster;
+ rados_ioctx_t ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
+ memset(buf, 0xcc, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
+ rados_list_ctx_t ctx;
+ ASSERT_EQ(0, rados_objects_list_open(ioctx, &ctx));
+ const char *entry;
+ ASSERT_EQ(0, rados_objects_list_next(ctx, &entry, NULL));
+ ASSERT_EQ(std::string(entry), "foo");
+ ASSERT_EQ(-ENOENT, rados_objects_list_next(ctx, &entry, NULL));
+ rados_objects_list_close(ctx);
+ rados_ioctx_destroy(ioctx);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosList, ListObjectsPP) {
+ std::string pool_name = get_temp_pool_name();
+ Rados cluster;
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ IoCtx ioctx;
+ cluster.ioctx_create(pool_name.c_str(), ioctx);
+ char buf[128];
+ memset(buf, 0xcc, sizeof(buf));
+ bufferlist bl1;
+ bl1.append(buf, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl1, sizeof(buf), 0));
+ ObjectIterator iter(ioctx.objects_begin());
+ ASSERT_EQ((iter == ioctx.objects_end()), false);
+ ASSERT_EQ((*iter).first, "foo");
+ ++iter;
+ ASSERT_EQ(true, (iter == ioctx.objects_end()));
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
--- /dev/null
+#include "mds/mdstypes.h"
+#include "include/buffer.h"
+#include "include/rbd_types.h"
+#include "include/rados/librados.h"
+#include "include/rados/librados.hpp"
+#include "test/librados/test.h"
+
+#include "gtest/gtest.h"
+#include <errno.h>
+#include <map>
+#include <sstream>
+#include <string>
+
+using namespace librados;
+using ceph::buffer;
+using std::map;
+using std::ostringstream;
+using std::string;
+
+TEST(LibRadosMisc, Version) {
+ int major, minor, extra;
+ rados_version(&major, &minor, &extra);
+}
+
+TEST(LibRadosMisc, VersionPP) {
+ int major, minor, extra;
+ Rados::version(&major, &minor, &extra);
+}
+
+TEST(LibRadosMisc, ClusterFSID) {
+ rados_t cluster;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+
+ char fsid[37];
+ ASSERT_EQ(-ERANGE, rados_cluster_fsid(cluster, fsid, sizeof(fsid) - 1));
+ ASSERT_EQ(sizeof(fsid) - 1,
+ (size_t)rados_cluster_fsid(cluster, fsid, sizeof(fsid)));
+
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+static std::string read_key_from_tmap(IoCtx& ioctx, const std::string &obj,
+ const std::string &key)
+{
+ bufferlist bl;
+ int r = ioctx.read(obj, bl, 0, 0);
+ if (r <= 0) {
+ ostringstream oss;
+ oss << "ioctx.read(" << obj << ", bl, 0, 0) returned " << r;
+ return oss.str();
+ }
+ bufferlist::iterator p = bl.begin();
+ bufferlist header;
+ map<string, bufferlist> m;
+ ::decode(header, p);
+ ::decode(m, p);
+ map<string, bufferlist>::iterator i = m.find(key);
+ if (i == m.end())
+ return "";
+ std::string retstring;
+ ::decode(retstring, i->second);
+ return retstring;
+}
+
+static std::string add_key_to_tmap(IoCtx &ioctx, const std::string &obj,
+ const std::string &key, const std::string &val)
+{
+ __u8 c = CEPH_OSD_TMAP_SET;
+
+ bufferlist tmbl;
+ ::encode(c, tmbl);
+ ::encode(key, tmbl);
+ bufferlist blbl;
+ ::encode(val, blbl);
+ ::encode(blbl, tmbl);
+ int ret = ioctx.tmap_update(obj, tmbl);
+ if (ret) {
+ ostringstream oss;
+ oss << "ioctx.tmap_update(obj=" << obj << ", key="
+ << key << ", val=" << val << ") failed with error " << ret;
+ return oss.str();
+ }
+ return "";
+}
+
+static int remove_key_from_tmap(IoCtx &ioctx, const std::string &obj,
+ const std::string &key)
+{
+ __u8 c = CEPH_OSD_TMAP_RM;
+
+ bufferlist tmbl;
+ ::encode(c, tmbl);
+ ::encode(key, tmbl);
+ int ret = ioctx.tmap_update(obj, tmbl);
+ if (ret) {
+ ostringstream oss;
+ oss << "ioctx.tmap_update(obj=" << obj << ", key="
+ << key << ") failed with error " << ret;
+ }
+ return ret;
+}
+
+TEST(LibRadosMisc, TmapUpdatePP) {
+ Rados cluster;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ IoCtx ioctx;
+ cluster.ioctx_create(pool_name.c_str(), ioctx);
+
+ // create tmap
+ {
+ __u8 c = CEPH_OSD_TMAP_CREATE;
+ std::string my_tmap("my_tmap");
+ bufferlist emptybl;
+
+ bufferlist tmbl;
+ ::encode(c, tmbl);
+ ::encode(my_tmap, tmbl);
+ ::encode(emptybl, tmbl);
+ ASSERT_EQ(0, ioctx.tmap_update("foo", tmbl));
+ }
+
+ ASSERT_EQ(string(""), add_key_to_tmap(ioctx, "foo", "key1", "val1"));
+
+ ASSERT_EQ(string(""), add_key_to_tmap(ioctx, "foo", "key2", "val2"));
+
+ // read key1 from the tmap
+ ASSERT_EQ(string("val1"), read_key_from_tmap(ioctx, "foo", "key1"));
+
+ // remove key1 from tmap
+ ASSERT_EQ(0, remove_key_from_tmap(ioctx, "foo", "key1"));
+ ASSERT_EQ(-ENOENT, remove_key_from_tmap(ioctx, "foo", "key1"));
+
+ // key should be removed
+ ASSERT_EQ(string(""), read_key_from_tmap(ioctx, "foo", "key1"));
+
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
+
+TEST(LibRadosMisc, Exec) {
+ char buf[128];
+ rados_t cluster;
+ rados_ioctx_t ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
+ memset(buf, 0xcc, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
+ char buf2[512];
+ int res = rados_exec(ioctx, "foo", "rbd", "get_all_features",
+ NULL, 0, buf2, sizeof(buf2));
+ ASSERT_GT(res, 0);
+ bufferlist bl;
+ bl.append(buf2, res);
+ bufferlist::iterator iter = bl.begin();
+ uint64_t all_features;
+ ::decode(all_features, iter);
+ ASSERT_EQ(all_features, (uint64_t)RBD_FEATURES_ALL);
+ rados_ioctx_destroy(ioctx);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosMisc, ExecPP) {
+ Rados cluster;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ IoCtx ioctx;
+ cluster.ioctx_create(pool_name.c_str(), ioctx);
+ bufferlist bl;
+ ASSERT_EQ(0, ioctx.write("foo", bl, 0, 0));
+ bufferlist bl2, out;
+ int r = ioctx.exec("foo", "rbd", "get_all_features", bl2, out);
+ ASSERT_EQ(0, r);
+ bufferlist::iterator iter = out.begin();
+ uint64_t all_features;
+ ::decode(all_features, iter);
+ ASSERT_EQ(all_features, (uint64_t)RBD_FEATURES_ALL);
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
+
+TEST(LibRadosMisc, Operate1PP) {
+ Rados cluster;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ IoCtx ioctx;
+ cluster.ioctx_create(pool_name.c_str(), ioctx);
+
+ ObjectWriteOperation o;
+ {
+ bufferlist bl;
+ o.write(0, bl);
+ }
+ std::string val1("val1");
+ {
+ bufferlist bl;
+ bl.append(val1.c_str(), val1.size() + 1);
+ o.setxattr("key1", bl);
+ }
+ ASSERT_EQ(0, ioctx.operate("foo", &o));
+ {
+ bufferlist bl;
+ ASSERT_GT(ioctx.getxattr("foo", "key1", bl), 0);
+ ASSERT_EQ(0, strcmp(bl.c_str(), val1.c_str()));
+ }
+ ObjectWriteOperation o2;
+ {
+ bufferlist bl;
+ bl.append(val1);
+ o2.cmpxattr("key1", CEPH_OSD_CMPXATTR_OP_EQ, bl);
+ o2.rmxattr("key1");
+ }
+ ASSERT_EQ(0, ioctx.operate("foo", &o2));
+ ObjectWriteOperation o3;
+ {
+ bufferlist bl;
+ bl.append(val1);
+ o3.cmpxattr("key1", CEPH_OSD_CMPXATTR_OP_EQ, bl);
+ }
+ ASSERT_LT(ioctx.operate("foo", &o3), 0);
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
+
+TEST(LibRadosMisc, Operate2PP) {
+ Rados cluster;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ IoCtx ioctx;
+ cluster.ioctx_create(pool_name.c_str(), ioctx);
+
+ ObjectWriteOperation o;
+ {
+ bufferlist bl;
+ bl.append("abcdefg");
+ o.write(0, bl);
+ }
+ std::string val1("val1");
+ {
+ bufferlist bl;
+ bl.append(val1.c_str(), val1.size() + 1);
+ o.setxattr("key1", bl);
+ o.truncate(0);
+ }
+ ASSERT_EQ(0, ioctx.operate("foo", &o));
+ uint64_t size;
+ time_t mtime;
+ ASSERT_EQ(0, ioctx.stat("foo", &size, &mtime));
+ ASSERT_EQ(0U, size);
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
+
+void set_completion_complete(rados_completion_t cb, void *arg)
+{
+ bool *my_aio_complete = (bool*)arg;
+ *my_aio_complete = true;
+}
+
+TEST(LibRadosMisc, AioOperatePP) {
+ Rados cluster;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ IoCtx ioctx;
+ cluster.ioctx_create(pool_name.c_str(), ioctx);
+
+ bool my_aio_complete = false;
+ AioCompletion *my_completion = cluster.aio_create_completion(
+ (void*)&my_aio_complete, set_completion_complete, NULL);
+ AioCompletion *my_completion_null = NULL;
+ ASSERT_NE(my_completion, my_completion_null);
+
+ ObjectWriteOperation o;
+ {
+ bufferlist bl;
+ o.write(0, bl);
+ }
+ std::string val1("val1");
+ {
+ bufferlist bl;
+ bl.append(val1.c_str(), val1.size() + 1);
+ o.setxattr("key1", bl);
+ bufferlist bl2;
+ char buf2[1024];
+ memset(buf2, 0xdd, sizeof(buf2));
+ bl2.append(buf2, sizeof(buf2));
+ o.append(bl2);
+ }
+ ASSERT_EQ(0, ioctx.aio_operate("foo", my_completion, &o));
+ ASSERT_EQ(0, my_completion->wait_for_complete_and_cb());
+ ASSERT_EQ(my_aio_complete, true);
+
+ uint64_t size;
+ time_t mtime;
+ ASSERT_EQ(0, ioctx.stat("foo", &size, &mtime));
+ ASSERT_EQ(1024U, size);
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
+
+TEST(LibRadosMisc, CloneRangePP) {
+ Rados cluster;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ IoCtx ioctx;
+ ASSERT_EQ(0, cluster.ioctx_create(pool_name.c_str(), ioctx));
+ char buf[64];
+ memset(buf, 0xcc, sizeof(buf));
+ bufferlist bl;
+ bl.append(buf, sizeof(buf));
+ ASSERT_EQ(sizeof(buf), (size_t)ioctx.write("foo", bl, sizeof(buf), 0));
+ ioctx.locator_set_key("foo");
+ ASSERT_EQ(0, ioctx.clone_range("bar", 0, "foo", 0, sizeof(buf)));
+ bufferlist bl2;
+ ASSERT_EQ(sizeof(buf), (size_t)ioctx.read("bar", bl2, sizeof(buf), 0));
+ ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf)));
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
+
+TEST(LibRadosMisc, CloneRange) {
+ char buf[128];
+ rados_t cluster;
+ rados_ioctx_t ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
+ memset(buf, 0xcc, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "src", buf, sizeof(buf), 0));
+ rados_ioctx_locator_set_key(ioctx, "src");
+ ASSERT_EQ(0, rados_clone_range(ioctx, "dst", 0, "src", 0, sizeof(buf)));
+ char buf2[sizeof(buf)];
+ memset(buf2, 0, sizeof(buf2));
+ ASSERT_EQ((int)sizeof(buf2), rados_read(ioctx, "dst", buf2, sizeof(buf2), 0));
+ ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf)));
+ rados_ioctx_destroy(ioctx);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosMisc, AssertExistsPP) {
+ Rados cluster;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ IoCtx ioctx;
+ ASSERT_EQ(0, cluster.ioctx_create(pool_name.c_str(), ioctx));
+
+ char buf[64];
+ memset(buf, 0xcc, sizeof(buf));
+ bufferlist bl;
+ bl.append(buf, sizeof(buf));
+
+ ObjectWriteOperation op;
+ op.assert_exists();
+ op.write(0, bl);
+ ASSERT_EQ(-ENOENT, ioctx.operate("asdffoo", &op));
+ ASSERT_EQ(0, ioctx.create("asdffoo", true));
+ ASSERT_EQ(0, ioctx.operate("asdffoo", &op));
+ ASSERT_EQ(-EEXIST, ioctx.create("asdffoo", true));
+
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
--- /dev/null
+#include "include/rados/librados.h"
+#include "test/librados/test.h"
+
+#include "gtest/gtest.h"
+#include <errno.h>
+#include <vector>
+
+#define POOL_LIST_BUF_SZ 32768
+
+TEST(LibRadosPools, PoolList) {
+ std::vector<char> pool_list_buf(POOL_LIST_BUF_SZ, '\0');
+ char *buf = &pool_list_buf[0];
+ rados_t cluster;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ ASSERT_LT(rados_pool_list(cluster, buf, POOL_LIST_BUF_SZ), POOL_LIST_BUF_SZ);
+
+ bool found_pool = false;
+ while (buf[0] != '\0') {
+ if ((found_pool == false) && (strcmp(buf, pool_name.c_str()) == 0)) {
+ found_pool = true;
+ }
+ buf += strlen(buf) + 1;
+ }
+ ASSERT_EQ(found_pool, true);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+int64_t rados_pool_lookup(rados_t cluster, const char *pool_name);
+
+TEST(LibRadosPools, PoolLookup) {
+ rados_t cluster;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ ASSERT_LT(0, rados_pool_lookup(cluster, pool_name.c_str()));
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosPools, PoolLookup2) {
+ rados_t cluster;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ int64_t pool_id = rados_pool_lookup(cluster, pool_name.c_str());
+ ASSERT_GT(pool_id, 0);
+ rados_ioctx_t ioctx;
+ ASSERT_EQ(0, rados_ioctx_create(cluster, pool_name.c_str(), &ioctx));
+ int64_t pool_id2 = rados_ioctx_get_id(ioctx);
+ ASSERT_EQ(pool_id, pool_id2);
+ rados_ioctx_destroy(ioctx);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosPools, PoolDelete) {
+ rados_t cluster;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ ASSERT_EQ(0, rados_pool_delete(cluster, pool_name.c_str()));
+ ASSERT_GT(0, rados_pool_lookup(cluster, pool_name.c_str()));
+ ASSERT_EQ(0, rados_pool_create(cluster, pool_name.c_str()));
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosPools, PoolCreateDelete) {
+ rados_t cluster;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+
+ std::string n = pool_name + "abc123";
+ ASSERT_EQ(0, rados_pool_create(cluster, n.c_str()));
+ ASSERT_EQ(-EEXIST, rados_pool_create(cluster, n.c_str()));
+ ASSERT_EQ(0, rados_pool_delete(cluster, n.c_str()));
+ ASSERT_EQ(-ENOENT, rados_pool_delete(cluster, n.c_str()));
+
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosPools, AuidTest1) {
+ rados_t cluster;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ rados_ioctx_t ioctx;
+ ASSERT_EQ(0, rados_ioctx_create(cluster, pool_name.c_str(), &ioctx));
+ ASSERT_EQ(0, rados_ioctx_pool_set_auid(ioctx, 123));
+ uint64_t auid;
+ ASSERT_EQ(0, rados_ioctx_pool_get_auid(ioctx, &auid));
+ ASSERT_EQ(123ull, auid);
+ rados_ioctx_destroy(ioctx);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosPools, AuidTest2) {
+ rados_t cluster;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ ASSERT_EQ(0, rados_pool_delete(cluster, pool_name.c_str()));
+ ASSERT_EQ(0, rados_pool_create_with_auid(cluster, pool_name.c_str(), 456));
+ rados_ioctx_t ioctx;
+ ASSERT_EQ(0, rados_ioctx_create(cluster, pool_name.c_str(), &ioctx));
+ uint64_t auid;
+ ASSERT_EQ(0, rados_ioctx_pool_get_auid(ioctx, &auid));
+ ASSERT_EQ(456ull, auid);
+ rados_ioctx_destroy(ioctx);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosPools, PoolCreateWithCrushRule) {
+ rados_t cluster;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+
+ std::string pool2_name = get_temp_pool_name();
+ ASSERT_EQ(0, rados_pool_create_with_crush_rule(cluster,
+ pool2_name.c_str(), 0));
+ ASSERT_EQ(0, rados_pool_delete(cluster, pool2_name.c_str()));
+
+ std::string pool3_name = get_temp_pool_name();
+ ASSERT_EQ(0, rados_pool_create_with_all(cluster, pool3_name.c_str(),
+ 456ull, 0));
+ rados_ioctx_t ioctx;
+ ASSERT_EQ(0, rados_ioctx_create(cluster, pool3_name.c_str(), &ioctx));
+ uint64_t auid;
+ ASSERT_EQ(0, rados_ioctx_pool_get_auid(ioctx, &auid));
+ ASSERT_EQ(456ull, auid);
+ ASSERT_EQ(0, rados_pool_delete(cluster, pool3_name.c_str()));
+ rados_ioctx_destroy(ioctx);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
--- /dev/null
+#include "include/rados/librados.h"
+#include "test/librados/test.h"
+
+#include <algorithm>
+#include <errno.h>
+#include "gtest/gtest.h"
+#include <string>
+
+using namespace librados;
+using std::string;
+
+TEST(LibRadosSnapshots, SnapList) {
+ char buf[128];
+ rados_t cluster;
+ rados_ioctx_t ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
+ memset(buf, 0xcc, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
+ ASSERT_EQ(0, rados_ioctx_snap_create(ioctx, "snap1"));
+ rados_snap_t snaps[10];
+ ASSERT_EQ(1, rados_ioctx_snap_list(ioctx, snaps,
+ sizeof(snaps) / sizeof(snaps[0])));
+ rados_snap_t rid;
+ ASSERT_EQ(0, rados_ioctx_snap_lookup(ioctx, "snap1", &rid));
+ ASSERT_EQ(rid, snaps[0]);
+ rados_ioctx_destroy(ioctx);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosSnapshots, SnapListPP) {
+ Rados cluster;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ IoCtx ioctx;
+ cluster.ioctx_create(pool_name.c_str(), ioctx);
+ char buf[128];
+ memset(buf, 0xcc, sizeof(buf));
+ bufferlist bl1;
+ bl1.append(buf, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl1, sizeof(buf), 0));
+ ASSERT_EQ(0, ioctx.snap_create("snap1"));
+ std::vector<snap_t> snaps;
+ ASSERT_EQ(0, ioctx.snap_list(&snaps));
+ ASSERT_EQ(1U, snaps.size());
+ snap_t rid;
+ ASSERT_EQ(0, ioctx.snap_lookup("snap1", &rid));
+ ASSERT_EQ(rid, snaps[0]);
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
+
+TEST(LibRadosSnapshots, SnapRemove) {
+ char buf[128];
+ rados_t cluster;
+ rados_ioctx_t ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
+ memset(buf, 0xcc, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
+ ASSERT_EQ(0, rados_ioctx_snap_create(ioctx, "snap1"));
+ rados_snap_t rid;
+ ASSERT_EQ(0, rados_ioctx_snap_lookup(ioctx, "snap1", &rid));
+ ASSERT_EQ(-EEXIST, rados_ioctx_snap_create(ioctx, "snap1"));
+ ASSERT_EQ(0, rados_ioctx_snap_remove(ioctx, "snap1"));
+ ASSERT_EQ(-ENOENT, rados_ioctx_snap_lookup(ioctx, "snap1", &rid));
+ rados_ioctx_destroy(ioctx);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosSnapshots, SnapRemovePP) {
+ char buf[128];
+ Rados cluster;
+ IoCtx ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ cluster.ioctx_create(pool_name.c_str(), ioctx);
+ memset(buf, 0xcc, sizeof(buf));
+ bufferlist bl1;
+ bl1.append(buf, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl1, sizeof(buf), 0));
+ ASSERT_EQ(0, ioctx.snap_create("snap1"));
+ rados_snap_t rid;
+ ASSERT_EQ(0, ioctx.snap_lookup("snap1", &rid));
+ ASSERT_EQ(0, ioctx.snap_remove("snap1"));
+ ASSERT_EQ(-ENOENT, ioctx.snap_lookup("snap1", &rid));
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
+
+TEST(LibRadosSnapshots, Rollback) {
+ char buf[128];
+ rados_t cluster;
+ rados_ioctx_t ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
+ memset(buf, 0xcc, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
+ ASSERT_EQ(0, rados_ioctx_snap_create(ioctx, "snap1"));
+ char buf2[sizeof(buf)];
+ memset(buf2, 0xdd, sizeof(buf2));
+ ASSERT_EQ(0, rados_write_full(ioctx, "foo", buf2, sizeof(buf2)));
+ ASSERT_EQ(0, rados_rollback(ioctx, "foo", "snap1"));
+ char buf3[sizeof(buf)];
+ ASSERT_EQ((int)sizeof(buf3), rados_read(ioctx, "foo", buf3, sizeof(buf3), 0));
+ ASSERT_EQ(0, memcmp(buf, buf3, sizeof(buf)));
+ rados_ioctx_destroy(ioctx);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosSnapshots, RollbackPP) {
+ char buf[128];
+ Rados cluster;
+ IoCtx ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ cluster.ioctx_create(pool_name.c_str(), ioctx);
+ memset(buf, 0xcc, sizeof(buf));
+ bufferlist bl1;
+ bl1.append(buf, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl1, sizeof(buf), 0));
+ ASSERT_EQ(0, ioctx.snap_create("snap1"));
+ char buf2[sizeof(buf)];
+ memset(buf2, 0xdd, sizeof(buf2));
+ bufferlist bl2;
+ bl2.append(buf2, sizeof(buf2));
+ ASSERT_EQ(0, ioctx.write_full("foo", bl2));
+ ASSERT_EQ(0, ioctx.rollback("foo", "snap1"));
+ bufferlist bl3;
+ ASSERT_EQ((int)sizeof(buf), ioctx.read("foo", bl3, sizeof(buf), 0));
+ ASSERT_EQ(0, memcmp(buf, bl3.c_str(), sizeof(buf)));
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
+
+TEST(LibRadosSnapshots, SnapGetName) {
+ char buf[128];
+ rados_t cluster;
+ rados_ioctx_t ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
+ memset(buf, 0xcc, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
+ ASSERT_EQ(0, rados_ioctx_snap_create(ioctx, "snapfoo"));
+ rados_snap_t rid;
+ ASSERT_EQ(0, rados_ioctx_snap_lookup(ioctx, "snapfoo", &rid));
+ ASSERT_EQ(-ENOENT, rados_ioctx_snap_lookup(ioctx, "snapbar", &rid));
+ char name[128];
+ memset(name, 0, sizeof(name));
+ ASSERT_EQ(0, rados_ioctx_snap_get_name(ioctx, rid, name, sizeof(name)));
+ time_t snaptime;
+ ASSERT_EQ(0, rados_ioctx_snap_get_stamp(ioctx, rid, &snaptime));
+ ASSERT_EQ(0, strcmp(name, "snapfoo"));
+ rados_ioctx_destroy(ioctx);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosSnapshots, SnapGetNamePP) {
+ char buf[128];
+ Rados cluster;
+ IoCtx ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ cluster.ioctx_create(pool_name.c_str(), ioctx);
+ memset(buf, 0xcc, sizeof(buf));
+ bufferlist bl;
+ bl.append(buf, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl, sizeof(buf), 0));
+ ASSERT_EQ(0, ioctx.snap_create("snapfoo"));
+ rados_snap_t rid;
+ ASSERT_EQ(0, ioctx.snap_lookup("snapfoo", &rid));
+ ASSERT_EQ(-ENOENT, ioctx.snap_lookup("snapbar", &rid));
+ std::string name;
+ ASSERT_EQ(0, ioctx.snap_get_name(rid, &name));
+ time_t snaptime;
+ ASSERT_EQ(0, ioctx.snap_get_stamp(rid, &snaptime));
+ ASSERT_EQ(0, strcmp(name.c_str(), "snapfoo"));
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
+
+TEST(LibRadosSnapshots, SelfManagedSnapTest) {
+ std::vector<uint64_t> my_snaps;
+ rados_t cluster;
+ rados_ioctx_t ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ ASSERT_EQ(0, rados_ioctx_create(cluster, pool_name.c_str(), &ioctx));
+
+ my_snaps.push_back(-2);
+ ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_create(ioctx, &my_snaps.back()));
+ ::std::reverse(my_snaps.begin(), my_snaps.end());
+ ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_set_write_ctx(ioctx, my_snaps[0],
+ &my_snaps[0], my_snaps.size()));
+ ::std::reverse(my_snaps.begin(), my_snaps.end());
+ char buf[128];
+ memset(buf, 0xcc, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
+
+ my_snaps.push_back(-2);
+ ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_create(ioctx, &my_snaps.back()));
+ ::std::reverse(my_snaps.begin(), my_snaps.end());
+ ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_set_write_ctx(ioctx, my_snaps[0],
+ &my_snaps[0], my_snaps.size()));
+ ::std::reverse(my_snaps.begin(), my_snaps.end());
+ char buf2[sizeof(buf)];
+ memset(buf2, 0xdd, sizeof(buf2));
+ ASSERT_EQ((int)sizeof(buf2), rados_write(ioctx, "foo", buf2, sizeof(buf2), 0));
+ rados_ioctx_snap_set_read(ioctx, my_snaps[1]);
+ char buf3[sizeof(buf)];
+ ASSERT_EQ((int)sizeof(buf3), rados_read(ioctx, "foo", buf3, sizeof(buf3), 0));
+ ASSERT_EQ(0, memcmp(buf3, buf, sizeof(buf)));
+
+ ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_remove(ioctx, my_snaps.back()));
+ my_snaps.pop_back();
+ ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_remove(ioctx, my_snaps.back()));
+ my_snaps.pop_back();
+ rados_ioctx_destroy(ioctx);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosSnapshots, SelfManagedRollbackTest) {
+ std::vector<uint64_t> my_snaps;
+ rados_t cluster;
+ rados_ioctx_t ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ ASSERT_EQ(0, rados_ioctx_create(cluster, pool_name.c_str(), &ioctx));
+
+ my_snaps.push_back(-2);
+ ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_create(ioctx, &my_snaps.back()));
+ ::std::reverse(my_snaps.begin(), my_snaps.end());
+ ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_set_write_ctx(ioctx, my_snaps[0],
+ &my_snaps[0], my_snaps.size()));
+ ::std::reverse(my_snaps.begin(), my_snaps.end());
+ char buf[128];
+ memset(buf, 0xcc, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
+
+ my_snaps.push_back(-2);
+ ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_create(ioctx, &my_snaps.back()));
+ ::std::reverse(my_snaps.begin(), my_snaps.end());
+ ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_set_write_ctx(ioctx, my_snaps[0],
+ &my_snaps[0], my_snaps.size()));
+ ::std::reverse(my_snaps.begin(), my_snaps.end());
+ char buf2[sizeof(buf)];
+ memset(buf2, 0xdd, sizeof(buf2));
+ ASSERT_EQ((int)sizeof(buf2), rados_write(ioctx, "foo", buf2, sizeof(buf2), 0));
+ rados_ioctx_selfmanaged_snap_rollback(ioctx, "foo", my_snaps[1]);
+ char buf3[sizeof(buf)];
+ ASSERT_EQ((int)sizeof(buf3), rados_read(ioctx, "foo", buf3, sizeof(buf3), 0));
+ ASSERT_EQ(0, memcmp(buf3, buf, sizeof(buf)));
+
+ ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_remove(ioctx, my_snaps.back()));
+ my_snaps.pop_back();
+ ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_remove(ioctx, my_snaps.back()));
+ my_snaps.pop_back();
+ rados_ioctx_destroy(ioctx);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosSnapshots, SelfManagedSnapTestPP) {
+ std::vector<uint64_t> my_snaps;
+ Rados cluster;
+ IoCtx ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ ASSERT_EQ(0, cluster.ioctx_create(pool_name.c_str(), ioctx));
+
+ my_snaps.push_back(-2);
+ ASSERT_EQ(0, ioctx.selfmanaged_snap_create(&my_snaps.back()));
+ ::std::reverse(my_snaps.begin(), my_snaps.end());
+ ASSERT_EQ(0, ioctx.selfmanaged_snap_set_write_ctx(my_snaps[0], my_snaps));
+ ::std::reverse(my_snaps.begin(), my_snaps.end());
+ char buf[128];
+ memset(buf, 0xcc, sizeof(buf));
+ bufferlist bl1;
+ bl1.append(buf, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl1, sizeof(buf), 0));
+
+ my_snaps.push_back(-2);
+ ASSERT_EQ(0, ioctx.selfmanaged_snap_create(&my_snaps.back()));
+ ::std::reverse(my_snaps.begin(), my_snaps.end());
+ ASSERT_EQ(0, ioctx.selfmanaged_snap_set_write_ctx(my_snaps[0], my_snaps));
+ ::std::reverse(my_snaps.begin(), my_snaps.end());
+ char buf2[sizeof(buf)];
+ memset(buf2, 0xdd, sizeof(buf2));
+ bufferlist bl2;
+ bl2.append(buf2, sizeof(buf2));
+ ASSERT_EQ((int)sizeof(buf2), ioctx.write("foo", bl2, sizeof(buf2), 0));
+
+ ioctx.snap_set_read(my_snaps[1]);
+ bufferlist bl3;
+ ASSERT_EQ((int)sizeof(buf), ioctx.read("foo", bl3, sizeof(buf), 0));
+ ASSERT_EQ(0, memcmp(bl3.c_str(), buf, sizeof(buf)));
+
+ ASSERT_EQ(0, ioctx.selfmanaged_snap_remove(my_snaps.back()));
+ my_snaps.pop_back();
+ ASSERT_EQ(0, ioctx.selfmanaged_snap_remove(my_snaps.back()));
+ my_snaps.pop_back();
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
+
+TEST(LibRadosSnapshots, SelfManagedSnapRollbackPP) {
+ std::vector<uint64_t> my_snaps;
+ Rados cluster;
+ IoCtx ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ ASSERT_EQ(0, cluster.ioctx_create(pool_name.c_str(), ioctx));
+
+ my_snaps.push_back(-2);
+ ASSERT_EQ(0, ioctx.selfmanaged_snap_create(&my_snaps.back()));
+ ::std::reverse(my_snaps.begin(), my_snaps.end());
+ ASSERT_EQ(0, ioctx.selfmanaged_snap_set_write_ctx(my_snaps[0], my_snaps));
+ ::std::reverse(my_snaps.begin(), my_snaps.end());
+ char buf[128];
+ memset(buf, 0xcc, sizeof(buf));
+ bufferlist bl1;
+ bl1.append(buf, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl1, sizeof(buf), 0));
+
+ my_snaps.push_back(-2);
+ ASSERT_EQ(0, ioctx.selfmanaged_snap_create(&my_snaps.back()));
+ ::std::reverse(my_snaps.begin(), my_snaps.end());
+ ASSERT_EQ(0, ioctx.selfmanaged_snap_set_write_ctx(my_snaps[0], my_snaps));
+ ::std::reverse(my_snaps.begin(), my_snaps.end());
+ char buf2[sizeof(buf)];
+ memset(buf2, 0xdd, sizeof(buf2));
+ bufferlist bl2;
+ bl2.append(buf2, sizeof(buf2));
+ ASSERT_EQ((int)sizeof(buf2), ioctx.write("foo", bl2, sizeof(buf2), 0));
+
+ string foo_str("foo");
+ ioctx.selfmanaged_snap_rollback(foo_str, my_snaps[1]);
+ bufferlist bl3;
+ ASSERT_EQ((int)sizeof(buf), ioctx.read("foo", bl3, sizeof(buf), 0));
+ ASSERT_EQ(0, memcmp(bl3.c_str(), buf, sizeof(buf)));
+
+ ASSERT_EQ(0, ioctx.selfmanaged_snap_remove(my_snaps.back()));
+ my_snaps.pop_back();
+ ASSERT_EQ(0, ioctx.selfmanaged_snap_remove(my_snaps.back()));
+ my_snaps.pop_back();
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
--- /dev/null
+#include "include/rados/librados.h"
+#include "include/rados/librados.hpp"
+#include "test/librados/test.h"
+
+#include <algorithm>
+#include <errno.h>
+#include "gtest/gtest.h"
+
+using namespace librados;
+
+TEST(LibRadosStat, Stat) {
+ char buf[128];
+ rados_t cluster;
+ rados_ioctx_t ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
+ memset(buf, 0xcc, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
+ uint64_t size;
+ time_t mtime;
+ ASSERT_EQ(0, rados_stat(ioctx, "foo", &size, &mtime));
+ ASSERT_EQ(sizeof(buf), size);
+ ASSERT_EQ(-ENOENT, rados_stat(ioctx, "nonexistent", &size, &mtime));
+ rados_ioctx_destroy(ioctx);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosStat, StatPP) {
+ char buf[128];
+ Rados cluster;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ IoCtx ioctx;
+ cluster.ioctx_create(pool_name.c_str(), ioctx);
+ memset(buf, 0xcc, sizeof(buf));
+ bufferlist bl;
+ bl.append(buf, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl, sizeof(buf), 0));
+ uint64_t size;
+ time_t mtime;
+ ASSERT_EQ(0, ioctx.stat("foo", &size, &mtime));
+ ASSERT_EQ(sizeof(buf), size);
+ ASSERT_EQ(-ENOENT, ioctx.stat("nonexistent", &size, &mtime));
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
+
+TEST(LibRadosStat, ClusterStat) {
+ rados_t cluster;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ struct rados_cluster_stat_t result;
+ ASSERT_EQ(0, rados_cluster_stat(cluster, &result));
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosStat, ClusterStatPP) {
+ Rados cluster;
+ cluster_stat_t cstat;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ ASSERT_EQ(0, cluster.cluster_stat(cstat));
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
+
+TEST(LibRadosStat, PoolStat) {
+ char buf[128];
+ rados_t cluster;
+ rados_ioctx_t ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
+ char actual_pool_name[80];
+ unsigned l = rados_ioctx_get_pool_name(ioctx, actual_pool_name, sizeof(actual_pool_name));
+ ASSERT_EQ(strlen(actual_pool_name), l);
+ ASSERT_EQ(0, strcmp(actual_pool_name, pool_name.c_str()));
+ memset(buf, 0xff, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
+ struct rados_pool_stat_t stats;
+ memset(&stats, 0, sizeof(stats));
+ ASSERT_EQ(0, rados_ioctx_pool_stat(ioctx, &stats));
+ rados_ioctx_destroy(ioctx);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+}
+
+TEST(LibRadosStat, PoolStatPP) {
+ Rados cluster;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ IoCtx ioctx;
+ cluster.ioctx_create(pool_name.c_str(), ioctx);
+ std::string n = ioctx.get_pool_name();
+ ASSERT_EQ(n, pool_name);
+ char buf[128];
+ memset(buf, 0xff, sizeof(buf));
+ bufferlist bl1;
+ bl1.append(buf, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl1, sizeof(buf), 0));
+ std::list<std::string> v;
+ std::map<std::string,stats_map> stats;
+ ASSERT_EQ(0, cluster.get_pool_stats(v, stats));
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+}
--- /dev/null
+#include "include/rados/librados.h"
+#include "include/rados/librados.hpp"
+#include "test/librados/test.h"
+
+#include <sstream>
+#include <stdlib.h>
+#include <string>
+#include <time.h>
+#include <unistd.h>
+
+using namespace librados;
+
+std::string get_temp_pool_name()
+{
+ char hostname[80];
+ char out[80];
+ memset(hostname, 0, sizeof(hostname));
+ memset(out, 0, sizeof(out));
+ gethostname(hostname, sizeof(hostname)-1);
+ static int num = 1;
+ sprintf(out, "%s-%d-%d", hostname, getpid(), num);
+ num++;
+ std::string prefix("test-rados-api-");
+ prefix += out;
+ return prefix;
+}
+
+std::string create_one_pool(const std::string &pool_name, rados_t *cluster)
+{
+ int ret;
+ ret = rados_create(cluster, NULL);
+ if (ret) {
+ std::ostringstream oss;
+ oss << "rados_create failed with error " << ret;
+ return oss.str();
+ }
+ ret = rados_conf_read_file(*cluster, NULL);
+ if (ret) {
+ rados_shutdown(*cluster);
+ std::ostringstream oss;
+ oss << "rados_conf_read_file failed with error " << ret;
+ return oss.str();
+ }
+ rados_conf_parse_env(*cluster, NULL);
+ ret = rados_connect(*cluster);
+ if (ret) {
+ rados_shutdown(*cluster);
+ std::ostringstream oss;
+ oss << "rados_connect failed with error " << ret;
+ return oss.str();
+ }
+ ret = rados_pool_create(*cluster, pool_name.c_str());
+ if (ret) {
+ rados_shutdown(*cluster);
+ std::ostringstream oss;
+ oss << "rados_pool_create(" << pool_name << ") failed with error " << ret;
+ return oss.str();
+ }
+ return "";
+}
+
+std::string create_one_pool_pp(const std::string &pool_name, Rados &cluster)
+{
+ char *id = getenv("CEPH_CLIENT_ID");
+ if (id) std::cerr << "Client id is: " << id << std::endl;
+
+ int ret;
+ ret = cluster.init(id);
+ if (ret) {
+ std::ostringstream oss;
+ oss << "cluster.init failed with error " << ret;
+ return oss.str();
+ }
+ ret = cluster.conf_read_file(NULL);
+ if (ret) {
+ cluster.shutdown();
+ std::ostringstream oss;
+ oss << "cluster.conf_read_file failed with error " << ret;
+ return oss.str();
+ }
+ cluster.conf_parse_env(NULL);
+ ret = cluster.connect();
+ if (ret) {
+ cluster.shutdown();
+ std::ostringstream oss;
+ oss << "cluster.connect failed with error " << ret;
+ return oss.str();
+ }
+ ret = cluster.pool_create(pool_name.c_str());
+ if (ret) {
+ cluster.shutdown();
+ std::ostringstream oss;
+ oss << "cluster.pool_create(" << pool_name << ") failed with error " << ret;
+ return oss.str();
+ }
+ return "";
+}
+
+std::string connect_cluster_pp(Rados &cluster)
+{
+ char *id = getenv("CEPH_CLIENT_ID");
+ if (id) std::cerr << "Client id is: " << id << std::endl;
+
+ int ret;
+ ret = cluster.init(id);
+ if (ret) {
+ std::ostringstream oss;
+ oss << "cluster.init failed with error " << ret;
+ return oss.str();
+ }
+ ret = cluster.conf_read_file(NULL);
+ if (ret) {
+ cluster.shutdown();
+ std::ostringstream oss;
+ oss << "cluster.conf_read_file failed with error " << ret;
+ return oss.str();
+ }
+ cluster.conf_parse_env(NULL);
+ ret = cluster.connect();
+ if (ret) {
+ cluster.shutdown();
+ std::ostringstream oss;
+ oss << "cluster.connect failed with error " << ret;
+ return oss.str();
+ }
+ return "";
+}
+
+int destroy_one_pool(const std::string &pool_name, rados_t *cluster)
+{
+ int ret = rados_pool_delete(*cluster, pool_name.c_str());
+ if (ret) {
+ rados_shutdown(*cluster);
+ return ret;
+ }
+ rados_shutdown(*cluster);
+ return 0;
+}
+
+int destroy_one_pool_pp(const std::string &pool_name, Rados &cluster)
+{
+ int ret = cluster.pool_delete(pool_name.c_str());
+ if (ret) {
+ cluster.shutdown();
+ return ret;
+ }
+ cluster.shutdown();
+ return 0;
+}
--- /dev/null
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab
+/*
+ * Ceph - scalable distributed file system
+ *
+ * Copyright (C) 2011 New Dream Network
+ *
+ * This is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License version 2.1, as published by the Free Software
+ * Foundation. See file COPYING.
+ *
+ */
+
+#ifndef CEPH_TEST_RADOS_API_TEST_H
+#define CEPH_TEST_RADOS_API_TEST_H
+
+#include "include/rados/librados.h"
+#include "include/rados/librados.hpp"
+
+#include <string>
+#include <unistd.h>
+
+std::string get_temp_pool_name();
+
+std::string create_one_pool(const std::string &pool_name, rados_t *cluster);
+std::string create_one_pool_pp(const std::string &pool_name,
+ librados::Rados &cluster);
+std::string connect_cluster_pp(librados::Rados &cluster);
+int destroy_one_pool(const std::string &pool_name, rados_t *cluster);
+int destroy_one_pool_pp(const std::string &pool_name, librados::Rados &cluster);
+
+class TestAlarm
+{
+public:
+ TestAlarm() {
+ alarm(360);
+ }
+ ~TestAlarm() {
+ alarm(0);
+ }
+};
+
+#endif
--- /dev/null
+#include "include/rados/librados.h"
+#include "include/rados/librados.hpp"
+#include "test/librados/test.h"
+
+#include <errno.h>
+#include <semaphore.h>
+#include "gtest/gtest.h"
+
+using namespace librados;
+
+static sem_t sem;
+
+static void watch_notify_test_cb(uint8_t opcode, uint64_t ver, void *arg)
+{
+ sem_post(&sem);
+}
+
+class WatchNotifyTestCtx : public WatchCtx
+{
+public:
+ void notify(uint8_t opcode, uint64_t ver, bufferlist& bl)
+ {
+ sem_post(&sem);
+ }
+};
+
+TEST(LibRadosWatchNotify, WatchNotifyTest) {
+ ASSERT_EQ(0, sem_init(&sem, 0, 0));
+ char buf[128];
+ rados_t cluster;
+ rados_ioctx_t ioctx;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool(pool_name, &cluster));
+ rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
+ memset(buf, 0xcc, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
+ uint64_t handle;
+ ASSERT_EQ(0,
+ rados_watch(ioctx, "foo", 0, &handle, watch_notify_test_cb, NULL));
+ ASSERT_EQ(0, rados_notify(ioctx, "foo", 0, NULL, 0));
+ TestAlarm alarm;
+ sem_wait(&sem);
+ rados_unwatch(ioctx, "foo", handle);
+ rados_ioctx_destroy(ioctx);
+ ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
+ sem_destroy(&sem);
+}
+
+TEST(LibRadosWatchNotify, WatchNotifyTestPP) {
+ ASSERT_EQ(0, sem_init(&sem, 0, 0));
+ Rados cluster;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ IoCtx ioctx;
+ cluster.ioctx_create(pool_name.c_str(), ioctx);
+ char buf[128];
+ memset(buf, 0xcc, sizeof(buf));
+ bufferlist bl1;
+ bl1.append(buf, sizeof(buf));
+ ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl1, sizeof(buf), 0));
+ uint64_t handle;
+ WatchNotifyTestCtx ctx;
+ ASSERT_EQ(0, ioctx.watch("foo", 0, &handle, &ctx));
+ bufferlist bl2;
+ ASSERT_EQ(0, ioctx.notify("foo", 0, bl2));
+ TestAlarm alarm;
+ sem_wait(&sem);
+ ioctx.unwatch("foo", handle);
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+ sem_destroy(&sem);
+}
+
+TEST(LibRadosWatchNotify, WatchNotifyTimeoutTestPP) {
+ ASSERT_EQ(0, sem_init(&sem, 0, 0));
+ Rados cluster;
+ std::string pool_name = get_temp_pool_name();
+ ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
+ IoCtx ioctx;
+ cluster.ioctx_create(pool_name.c_str(), ioctx);
+ ioctx.set_notify_timeout(1);
+ uint64_t handle;
+ WatchNotifyTestCtx ctx;
+ ASSERT_EQ(0, ioctx.watch("foo", 0, &handle, &ctx));
+ ioctx.close();
+ ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
+ sem_destroy(&sem);
+}
#include <algorithm>
#include <sstream>
-#include "rados-api/test.h"
+#include "test/librados/test.h"
#include "common/errno.h"
#include "include/stringify.h"
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
#include "include/rados/librados.h"
#include "include/rados/librados.hpp"
-#include "test/rados-api/test.h"
+#include "test/librados/test.h"
#include <semaphore.h>
#include <errno.h>
#include "Object.h"
#include "TestOpStat.h"
#include "inttypes.h"
-#include "test/rados-api/test.h"
+#include "test/librados/test.h"
#ifndef RADOSMODEL_H
#define RADOSMODEL_H
+++ /dev/null
-#include "common/errno.h"
-#include "include/rados/librados.h"
-#include "test/rados-api/test.h"
-#include "include/types.h"
-
-#include "gtest/gtest.h"
-#include <errno.h>
-#include <semaphore.h>
-#include <sstream>
-#include <string>
-#include <boost/scoped_ptr.hpp>
-#include <utility>
-
-using std::ostringstream;
-using namespace librados;
-using std::pair;
-using std::make_pair;
-
-class AioTestData
-{
-public:
- AioTestData()
- : m_cluster(NULL),
- m_init(false),
- m_complete(false),
- m_safe(false)
- {
- }
-
- ~AioTestData()
- {
- if (m_init) {
- rados_ioctx_destroy(m_ioctx);
- destroy_one_pool(m_pool_name, &m_cluster);
- sem_destroy(&m_sem);
- }
- }
-
- std::string init()
- {
- int ret;
- if (sem_init(&m_sem, 0, 0)) {
- int err = errno;
- sem_destroy(&m_sem);
- ostringstream oss;
- oss << "sem_init failed: " << cpp_strerror(err);
- return oss.str();
- }
- m_pool_name = get_temp_pool_name();
- std::string err = create_one_pool(m_pool_name, &m_cluster);
- if (!err.empty()) {
- sem_destroy(&m_sem);
- ostringstream oss;
- oss << "create_one_pool(" << m_pool_name << ") failed: error " << err;
- return oss.str();
- }
- ret = rados_ioctx_create(m_cluster, m_pool_name.c_str(), &m_ioctx);
- if (ret) {
- sem_destroy(&m_sem);
- destroy_one_pool(m_pool_name, &m_cluster);
- ostringstream oss;
- oss << "rados_ioctx_create failed: error " << ret;
- return oss.str();
- }
- m_init = true;
- return "";
- }
-
- sem_t m_sem;
- rados_t m_cluster;
- rados_ioctx_t m_ioctx;
- std::string m_pool_name;
- bool m_init;
- bool m_complete;
- bool m_safe;
-};
-
-class AioTestDataPP
-{
-public:
- AioTestDataPP()
- : m_init(false),
- m_complete(false),
- m_safe(false)
- {
- }
-
- ~AioTestDataPP()
- {
- if (m_init) {
- m_ioctx.close();
- destroy_one_pool_pp(m_pool_name, m_cluster);
- sem_destroy(&m_sem);
- }
- }
-
- std::string init()
- {
- int ret;
- if (sem_init(&m_sem, 0, 0)) {
- int err = errno;
- sem_destroy(&m_sem);
- ostringstream oss;
- oss << "sem_init failed: " << cpp_strerror(err);
- return oss.str();
- }
- m_pool_name = get_temp_pool_name();
- std::string err = create_one_pool_pp(m_pool_name, m_cluster);
- if (!err.empty()) {
- sem_destroy(&m_sem);
- ostringstream oss;
- oss << "create_one_pool(" << m_pool_name << ") failed: error " << err;
- return oss.str();
- }
- ret = m_cluster.ioctx_create(m_pool_name.c_str(), m_ioctx);
- if (ret) {
- sem_destroy(&m_sem);
- destroy_one_pool_pp(m_pool_name, m_cluster);
- ostringstream oss;
- oss << "rados_ioctx_create failed: error " << ret;
- return oss.str();
- }
- m_init = true;
- return "";
- }
-
- sem_t m_sem;
- Rados m_cluster;
- IoCtx m_ioctx;
- std::string m_pool_name;
- bool m_init;
- bool m_complete;
- bool m_safe;
-};
-
-void set_completion_complete(rados_completion_t cb, void *arg)
-{
- AioTestData *test = (AioTestData*)arg;
- test->m_complete = true;
- sem_post(&test->m_sem);
-}
-
-void set_completion_safe(rados_completion_t cb, void *arg)
-{
- AioTestData *test = (AioTestData*)arg;
- test->m_safe = true;
- sem_post(&test->m_sem);
-}
-
-TEST(LibRadosAio, SimpleWrite) {
- AioTestData test_data;
- rados_completion_t my_completion;
- ASSERT_EQ("", test_data.init());
- ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
- set_completion_complete, set_completion_safe, &my_completion));
- char buf[128];
- memset(buf, 0xcc, sizeof(buf));
- ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
- my_completion, buf, sizeof(buf), 0));
- TestAlarm alarm;
- sem_wait(&test_data.m_sem);
- sem_wait(&test_data.m_sem);
- rados_aio_release(my_completion);
-}
-
-TEST(LibRadosAio, SimpleWritePP) {
- AioTestDataPP test_data;
- ASSERT_EQ("", test_data.init());
- AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
- (void*)&test_data, set_completion_complete, set_completion_safe);
- AioCompletion *my_completion_null = NULL;
- ASSERT_NE(my_completion, my_completion_null);
- char buf[128];
- memset(buf, 0xcc, sizeof(buf));
- bufferlist bl1;
- bl1.append(buf, sizeof(buf));
- ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo",
- my_completion, bl1, sizeof(buf), 0));
- TestAlarm alarm;
- sem_wait(&test_data.m_sem);
- sem_wait(&test_data.m_sem);
- delete my_completion;
-}
-
-TEST(LibRadosAio, WaitForSafe) {
- AioTestData test_data;
- rados_completion_t my_completion;
- ASSERT_EQ("", test_data.init());
- ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
- set_completion_complete, set_completion_safe, &my_completion));
- char buf[128];
- memset(buf, 0xcc, sizeof(buf));
- ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
- my_completion, buf, sizeof(buf), 0));
- TestAlarm alarm;
- ASSERT_EQ(0, rados_aio_wait_for_safe(my_completion));
- rados_aio_release(my_completion);
-}
-
-TEST(LibRadosAio, WaitForSafePP) {
- AioTestDataPP test_data;
- ASSERT_EQ("", test_data.init());
- AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
- (void*)&test_data, set_completion_complete, set_completion_safe);
- AioCompletion *my_completion_null = NULL;
- ASSERT_NE(my_completion, my_completion_null);
- char buf[128];
- memset(buf, 0xcc, sizeof(buf));
- bufferlist bl1;
- bl1.append(buf, sizeof(buf));
- ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo",
- my_completion, bl1, sizeof(buf), 0));
- TestAlarm alarm;
- ASSERT_EQ(0, my_completion->wait_for_safe());
- delete my_completion;
-}
-
-TEST(LibRadosAio, RoundTrip) {
- AioTestData test_data;
- rados_completion_t my_completion;
- ASSERT_EQ("", test_data.init());
- ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
- set_completion_complete, set_completion_safe, &my_completion));
- char buf[128];
- memset(buf, 0xcc, sizeof(buf));
- ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
- my_completion, buf, sizeof(buf), 0));
- {
- TestAlarm alarm;
- sem_wait(&test_data.m_sem);
- sem_wait(&test_data.m_sem);
- }
- char buf2[128];
- memset(buf2, 0, sizeof(buf2));
- rados_completion_t my_completion2;
- ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
- set_completion_complete, set_completion_safe, &my_completion2));
- ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
- my_completion2, buf2, sizeof(buf2), 0));
- {
- TestAlarm alarm;
- ASSERT_EQ(0, rados_aio_wait_for_complete(my_completion2));
- }
- ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf)));
- rados_aio_release(my_completion);
- rados_aio_release(my_completion2);
-}
-
-TEST(LibRadosAio, RoundTrip2) {
- AioTestData test_data;
- rados_completion_t my_completion;
- ASSERT_EQ("", test_data.init());
- ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
- set_completion_complete, set_completion_safe, &my_completion));
- char buf[128];
- memset(buf, 0xcc, sizeof(buf));
- ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
- my_completion, buf, sizeof(buf), 0));
- {
- TestAlarm alarm;
- sem_wait(&test_data.m_sem);
- sem_wait(&test_data.m_sem);
- }
- char buf2[128];
- memset(buf2, 0, sizeof(buf2));
- rados_completion_t my_completion2;
- ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
- set_completion_complete, set_completion_safe, &my_completion2));
- ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
- my_completion2, buf2, sizeof(buf2), 0));
- {
- TestAlarm alarm;
- ASSERT_EQ(0, rados_aio_wait_for_safe(my_completion2));
- }
- ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf)));
- rados_aio_release(my_completion);
- rados_aio_release(my_completion2);
-}
-
-TEST(LibRadosAio, RoundTripPP) {
- AioTestDataPP test_data;
- ASSERT_EQ("", test_data.init());
- AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
- (void*)&test_data, set_completion_complete, set_completion_safe);
- AioCompletion *my_completion_null = NULL;
- ASSERT_NE(my_completion, my_completion_null);
- char buf[128];
- memset(buf, 0xcc, sizeof(buf));
- bufferlist bl1;
- bl1.append(buf, sizeof(buf));
- ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion,
- bl1, sizeof(buf), 0));
- {
- TestAlarm alarm;
- sem_wait(&test_data.m_sem);
- sem_wait(&test_data.m_sem);
- }
- bufferlist bl2;
- AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
- (void*)&test_data, set_completion_complete, set_completion_safe);
- ASSERT_NE(my_completion2, my_completion_null);
- ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo",
- my_completion2, &bl2, sizeof(buf), 0));
- {
- TestAlarm alarm;
- ASSERT_EQ(0, my_completion2->wait_for_complete());
- }
- ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf)));
- delete my_completion;
- delete my_completion2;
-}
-
-TEST(LibRadosAio, RoundTripPP2) {
- AioTestDataPP test_data;
- ASSERT_EQ("", test_data.init());
- AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
- (void*)&test_data, set_completion_complete, set_completion_safe);
- AioCompletion *my_completion_null = NULL;
- ASSERT_NE(my_completion, my_completion_null);
- char buf[128];
- memset(buf, 0xcc, sizeof(buf));
- bufferlist bl1;
- bl1.append(buf, sizeof(buf));
- ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion,
- bl1, sizeof(buf), 0));
- {
- TestAlarm alarm;
- sem_wait(&test_data.m_sem);
- sem_wait(&test_data.m_sem);
- }
- bufferlist bl2;
- AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
- (void*)&test_data, set_completion_complete, set_completion_safe);
- ASSERT_NE(my_completion2, my_completion_null);
- ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo",
- my_completion2, &bl2, sizeof(buf), 0));
- {
- TestAlarm alarm;
- ASSERT_EQ(0, my_completion2->wait_for_safe());
- }
- ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf)));
- delete my_completion;
- delete my_completion2;
-}
-
-TEST(LibRadosAio, RoundTripAppend) {
- AioTestData test_data;
- rados_completion_t my_completion, my_completion2, my_completion3;
- ASSERT_EQ("", test_data.init());
- ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
- set_completion_complete, set_completion_safe, &my_completion));
- char buf[128];
- memset(buf, 0xcc, sizeof(buf));
- ASSERT_EQ(0, rados_aio_append(test_data.m_ioctx, "foo",
- my_completion, buf, sizeof(buf)));
- {
- TestAlarm alarm;
- ASSERT_EQ(0, rados_aio_wait_for_complete(my_completion));
- }
- char buf2[128];
- memset(buf2, 0xdd, sizeof(buf2));
- ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
- set_completion_complete, set_completion_safe, &my_completion2));
- ASSERT_EQ(0, rados_aio_append(test_data.m_ioctx, "foo",
- my_completion2, buf2, sizeof(buf)));
- {
- TestAlarm alarm;
- ASSERT_EQ(0, rados_aio_wait_for_complete(my_completion2));
- }
- char buf3[sizeof(buf) + sizeof(buf2)];
- memset(buf3, 0, sizeof(buf3));
- ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
- set_completion_complete, set_completion_safe, &my_completion3));
- ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
- my_completion3, buf3, sizeof(buf3), 0));
- {
- TestAlarm alarm;
- ASSERT_EQ(0, rados_aio_wait_for_complete(my_completion3));
- }
- ASSERT_EQ(0, memcmp(buf3, buf, sizeof(buf)));
- ASSERT_EQ(0, memcmp(buf3 + sizeof(buf), buf2, sizeof(buf2)));
- rados_aio_release(my_completion);
- rados_aio_release(my_completion2);
- rados_aio_release(my_completion3);
-}
-
-TEST(LibRadosAio, RoundTripAppendPP) {
- AioTestDataPP test_data;
- ASSERT_EQ("", test_data.init());
- AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
- (void*)&test_data, set_completion_complete, set_completion_safe);
- AioCompletion *my_completion_null = NULL;
- ASSERT_NE(my_completion, my_completion_null);
- char buf[128];
- memset(buf, 0xcc, sizeof(buf));
- bufferlist bl1;
- bl1.append(buf, sizeof(buf));
- ASSERT_EQ(0, test_data.m_ioctx.aio_append("foo", my_completion,
- bl1, sizeof(buf)));
- {
- TestAlarm alarm;
- ASSERT_EQ(0, my_completion->wait_for_complete());
- }
- char buf2[128];
- memset(buf2, 0xdd, sizeof(buf2));
- bufferlist bl2;
- bl2.append(buf2, sizeof(buf2));
- AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
- (void*)&test_data, set_completion_complete, set_completion_safe);
- ASSERT_NE(my_completion2, my_completion_null);
- ASSERT_EQ(0, test_data.m_ioctx.aio_append("foo", my_completion2,
- bl2, sizeof(buf2)));
- {
- TestAlarm alarm;
- ASSERT_EQ(0, my_completion2->wait_for_complete());
- }
- bufferlist bl3;
- AioCompletion *my_completion3 = test_data.m_cluster.aio_create_completion(
- (void*)&test_data, set_completion_complete, set_completion_safe);
- ASSERT_NE(my_completion3, my_completion_null);
- ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo",
- my_completion3, &bl3, 2 * sizeof(buf), 0));
- {
- TestAlarm alarm;
- ASSERT_EQ(0, my_completion3->wait_for_complete());
- }
- ASSERT_EQ(0, memcmp(bl3.c_str(), buf, sizeof(buf)));
- ASSERT_EQ(0, memcmp(bl3.c_str() + sizeof(buf), buf2, sizeof(buf2)));
- delete my_completion;
- delete my_completion2;
- delete my_completion3;
-}
-
-TEST(LibRadosAio, IsComplete) {
- AioTestData test_data;
- rados_completion_t my_completion;
- ASSERT_EQ("", test_data.init());
- ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
- set_completion_complete, set_completion_safe, &my_completion));
- char buf[128];
- memset(buf, 0xcc, sizeof(buf));
- ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
- my_completion, buf, sizeof(buf), 0));
- {
- TestAlarm alarm;
- sem_wait(&test_data.m_sem);
- sem_wait(&test_data.m_sem);
- }
- char buf2[128];
- memset(buf2, 0, sizeof(buf2));
- rados_completion_t my_completion2;
- ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
- set_completion_complete, set_completion_safe, &my_completion2));
- ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
- my_completion2, buf2, sizeof(buf2), 0));
- {
- TestAlarm alarm;
-
- // Busy-wait until the AIO completes.
- // Normally we wouldn't do this, but we want to test rados_aio_is_complete.
- while (true) {
- int is_complete = rados_aio_is_complete(my_completion2);
- if (is_complete)
- break;
- }
- }
- ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf)));
- rados_aio_release(my_completion);
- rados_aio_release(my_completion2);
-}
-
-TEST(LibRadosAio, IsCompletePP) {
- AioTestDataPP test_data;
- ASSERT_EQ("", test_data.init());
- AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
- (void*)&test_data, set_completion_complete, set_completion_safe);
- AioCompletion *my_completion_null = NULL;
- ASSERT_NE(my_completion, my_completion_null);
- char buf[128];
- memset(buf, 0xcc, sizeof(buf));
- bufferlist bl1;
- bl1.append(buf, sizeof(buf));
- ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion,
- bl1, sizeof(buf), 0));
- {
- TestAlarm alarm;
- sem_wait(&test_data.m_sem);
- sem_wait(&test_data.m_sem);
- }
- bufferlist bl2;
- AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
- (void*)&test_data, set_completion_complete, set_completion_safe);
- ASSERT_NE(my_completion2, my_completion_null);
- ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2,
- &bl2, sizeof(buf), 0));
- {
- TestAlarm alarm;
-
- // Busy-wait until the AIO completes.
- // Normally we wouldn't do this, but we want to test rados_aio_is_complete.
- while (true) {
- int is_complete = my_completion2->is_complete();
- if (is_complete)
- break;
- }
- }
- ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf)));
- delete my_completion;
- delete my_completion2;
-}
-
-TEST(LibRadosAio, IsSafe) {
- AioTestData test_data;
- rados_completion_t my_completion;
- ASSERT_EQ("", test_data.init());
- ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
- set_completion_complete, set_completion_safe, &my_completion));
- char buf[128];
- memset(buf, 0xcc, sizeof(buf));
- ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
- my_completion, buf, sizeof(buf), 0));
- {
- TestAlarm alarm;
-
- // Busy-wait until the AIO completes.
- // Normally we wouldn't do this, but we want to test rados_aio_is_safe.
- while (true) {
- int is_safe = rados_aio_is_safe(my_completion);
- if (is_safe)
- break;
- }
- }
- char buf2[128];
- memset(buf2, 0, sizeof(buf2));
- rados_completion_t my_completion2;
- ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
- set_completion_complete, set_completion_safe, &my_completion2));
- ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
- my_completion2, buf2, sizeof(buf2), 0));
- {
- TestAlarm alarm;
- ASSERT_EQ(0, rados_aio_wait_for_complete(my_completion2));
- }
- ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf)));
- rados_aio_release(my_completion);
- rados_aio_release(my_completion2);
-}
-
-TEST(LibRadosAio, IsSafePP) {
- AioTestDataPP test_data;
- ASSERT_EQ("", test_data.init());
- AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
- (void*)&test_data, set_completion_complete, set_completion_safe);
- AioCompletion *my_completion_null = NULL;
- ASSERT_NE(my_completion, my_completion_null);
- char buf[128];
- memset(buf, 0xcc, sizeof(buf));
- bufferlist bl1;
- bl1.append(buf, sizeof(buf));
- ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion,
- bl1, sizeof(buf), 0));
- {
- TestAlarm alarm;
-
- // Busy-wait until the AIO completes.
- // Normally we wouldn't do this, but we want to test rados_aio_is_safe.
- while (true) {
- int is_safe = my_completion->is_safe();
- if (is_safe)
- break;
- }
- }
- AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
- (void*)&test_data, set_completion_complete, set_completion_safe);
- bufferlist bl2;
- ASSERT_NE(my_completion2, my_completion_null);
- ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2,
- &bl2, sizeof(buf), 0));
- {
- TestAlarm alarm;
- ASSERT_EQ(0, my_completion2->wait_for_complete());
- }
- ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf)));
- delete my_completion;
- delete my_completion2;
-}
-
-TEST(LibRadosAio, ReturnValue) {
- AioTestData test_data;
- rados_completion_t my_completion;
- ASSERT_EQ("", test_data.init());
- ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
- set_completion_complete, set_completion_safe, &my_completion));
- char buf[128];
- memset(buf, 0, sizeof(buf));
- ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "nonexistent",
- my_completion, buf, sizeof(buf), 0));
- {
- TestAlarm alarm;
- ASSERT_EQ(0, rados_aio_wait_for_complete(my_completion));
- }
- ASSERT_EQ(-ENOENT, rados_aio_get_return_value(my_completion));
- rados_aio_release(my_completion);
-}
-
-TEST(LibRadosAio, ReturnValuePP) {
- AioTestDataPP test_data;
- ASSERT_EQ("", test_data.init());
- AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
- (void*)&test_data, set_completion_complete, set_completion_safe);
- AioCompletion *my_completion_null = NULL;
- ASSERT_NE(my_completion, my_completion_null);
- bufferlist bl1;
- ASSERT_EQ(0, test_data.m_ioctx.aio_read("nonexistent",
- my_completion, &bl1, 128, 0));
- {
- TestAlarm alarm;
- ASSERT_EQ(0, my_completion->wait_for_complete());
- }
- ASSERT_EQ(-ENOENT, my_completion->get_return_value());
- delete my_completion;
-}
-
-TEST(LibRadosAio, Flush) {
- AioTestData test_data;
- rados_completion_t my_completion;
- ASSERT_EQ("", test_data.init());
- ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
- set_completion_complete, set_completion_safe, &my_completion));
- char buf[128];
- memset(buf, 0xee, sizeof(buf));
- ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
- my_completion, buf, sizeof(buf), 0));
- ASSERT_EQ(0, rados_aio_flush(test_data.m_ioctx));
- char buf2[128];
- memset(buf2, 0, sizeof(buf2));
- rados_completion_t my_completion2;
- ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
- set_completion_complete, set_completion_safe, &my_completion2));
- ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
- my_completion2, buf2, sizeof(buf2), 0));
- {
- TestAlarm alarm;
- ASSERT_EQ(0, rados_aio_wait_for_complete(my_completion2));
- }
- ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf)));
- rados_aio_release(my_completion);
- rados_aio_release(my_completion2);
-}
-
-TEST(LibRadosAio, FlushPP) {
- AioTestDataPP test_data;
- ASSERT_EQ("", test_data.init());
- AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
- (void*)&test_data, set_completion_complete, set_completion_safe);
- AioCompletion *my_completion_null = NULL;
- ASSERT_NE(my_completion, my_completion_null);
- char buf[128];
- memset(buf, 0xee, sizeof(buf));
- bufferlist bl1;
- bl1.append(buf, sizeof(buf));
- ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion,
- bl1, sizeof(buf), 0));
- ASSERT_EQ(0, test_data.m_ioctx.aio_flush());
- bufferlist bl2;
- AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
- (void*)&test_data, set_completion_complete, set_completion_safe);
- ASSERT_NE(my_completion2, my_completion_null);
- ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2,
- &bl2, sizeof(buf), 0));
- {
- TestAlarm alarm;
- ASSERT_EQ(0, my_completion2->wait_for_complete());
- }
- ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf)));
- delete my_completion;
- delete my_completion2;
-}
-
-TEST(LibRadosAio, RoundTripWriteFull) {
- AioTestData test_data;
- rados_completion_t my_completion, my_completion2, my_completion3;
- ASSERT_EQ("", test_data.init());
- ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
- set_completion_complete, set_completion_safe, &my_completion));
- char buf[128];
- memset(buf, 0xcc, sizeof(buf));
- ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
- my_completion, buf, sizeof(buf), 0));
- {
- TestAlarm alarm;
- ASSERT_EQ(0, rados_aio_wait_for_complete(my_completion));
- }
- char buf2[64];
- memset(buf2, 0xdd, sizeof(buf2));
- ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
- set_completion_complete, set_completion_safe, &my_completion2));
- ASSERT_EQ(0, rados_aio_write_full(test_data.m_ioctx, "foo",
- my_completion2, buf2, sizeof(buf2)));
- {
- TestAlarm alarm;
- ASSERT_EQ(0, rados_aio_wait_for_complete(my_completion2));
- }
- char buf3[sizeof(buf) + sizeof(buf2)];
- memset(buf3, 0, sizeof(buf3));
- ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
- set_completion_complete, set_completion_safe, &my_completion3));
- ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
- my_completion3, buf3, sizeof(buf3), 0));
- {
- TestAlarm alarm;
- ASSERT_EQ(0, rados_aio_wait_for_complete(my_completion3));
- }
- ASSERT_EQ(0, memcmp(buf3, buf2, sizeof(buf2)));
- rados_aio_release(my_completion);
- rados_aio_release(my_completion2);
- rados_aio_release(my_completion3);
-}
-
-TEST(LibRadosAio, RoundTripWriteFullPP) {
- AioTestDataPP test_data;
- ASSERT_EQ("", test_data.init());
- AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
- (void*)&test_data, set_completion_complete, set_completion_safe);
- AioCompletion *my_completion_null = NULL;
- ASSERT_NE(my_completion, my_completion_null);
- char buf[128];
- memset(buf, 0xcc, sizeof(buf));
- bufferlist bl1;
- bl1.append(buf, sizeof(buf));
- ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion,
- bl1, sizeof(buf), 0));
- {
- TestAlarm alarm;
- ASSERT_EQ(0, my_completion->wait_for_complete());
- }
- char buf2[64];
- memset(buf2, 0xdd, sizeof(buf2));
- bufferlist bl2;
- bl2.append(buf2, sizeof(buf2));
- AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
- (void*)&test_data, set_completion_complete, set_completion_safe);
- ASSERT_NE(my_completion2, my_completion_null);
- ASSERT_EQ(0, test_data.m_ioctx.aio_write_full("foo", my_completion2, bl2));
- {
- TestAlarm alarm;
- ASSERT_EQ(0, my_completion2->wait_for_complete());
- }
- bufferlist bl3;
- AioCompletion *my_completion3 = test_data.m_cluster.aio_create_completion(
- (void*)&test_data, set_completion_complete, set_completion_safe);
- ASSERT_NE(my_completion3, my_completion_null);
- ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion3,
- &bl3, sizeof(buf), 0));
- {
- TestAlarm alarm;
- ASSERT_EQ(0, my_completion3->wait_for_complete());
- }
- ASSERT_EQ(0, memcmp(bl3.c_str(), buf2, sizeof(buf2)));
- delete my_completion;
- delete my_completion2;
- delete my_completion3;
-}
-
-using std::string;
-using std::map;
-using std::set;
-
-TEST(LibRadosAio, OmapPP) {
- Rados cluster;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- IoCtx ioctx;
- cluster.ioctx_create(pool_name.c_str(), ioctx);
-
- string header_str = "baz";
- bufferptr bp(header_str.c_str(), header_str.size() + 1);
- bufferlist header_to_set;
- header_to_set.push_back(bp);
- map<string, bufferlist> to_set;
- {
- boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0, 0));
- ObjectWriteOperation op;
- string val = "bar";
- to_set["foo"] = header_to_set;
- to_set["foo2"] = header_to_set;
- to_set["qfoo3"] = header_to_set;
- op.omap_set(to_set);
-
- op.omap_set_header(header_to_set);
-
- ioctx.aio_operate("test_obj", my_completion.get(), &op);
- {
- TestAlarm alarm;
- ASSERT_EQ(0, my_completion->wait_for_complete());
- }
- }
-
- {
- boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0, 0));
- ObjectReadOperation op;
- map<string, pair<bufferlist, int> > assertions;
- bufferlist val;
- val.append(string("bar"));
- assertions["foo"] = pair<bufferlist, int>(val, CEPH_OSD_CMPXATTR_OP_EQ);
-
- int r;
- op.omap_cmp(assertions, &r);
-
- ioctx.aio_operate("test_obj", my_completion.get(), &op, 0);
- {
- TestAlarm alarm;
- ASSERT_EQ(0, my_completion->wait_for_complete());
- }
- ASSERT_EQ(0, r);
- }
-
- {
- boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0, 0));
- ObjectReadOperation op;
-
- set<string> set_got;
- map<string, bufferlist> map_got;
-
- set<string> to_get;
- map<string, bufferlist> got3;
-
- map<string, bufferlist> got4;
-
- bufferlist header;
-
- op.omap_get_keys("", 1, &set_got, 0);
- op.omap_get_vals("foo", 1, &map_got, 0);
-
- to_get.insert("foo");
- to_get.insert("qfoo3");
- op.omap_get_vals_by_keys(to_get, &got3, 0);
-
- op.omap_get_header(&header, 0);
-
- op.omap_get_vals("foo2", "q", 1, &got4, 0);
-
- ioctx.aio_operate("test_obj", my_completion.get(), &op, 0);
- {
- TestAlarm alarm;
- ASSERT_EQ(0, my_completion->wait_for_complete());
- }
-
- ASSERT_EQ(header.length(), header_to_set.length());
- ASSERT_EQ(set_got.size(), (unsigned)1);
- ASSERT_EQ(*set_got.begin(), "foo");
- ASSERT_EQ(map_got.size(), (unsigned)1);
- ASSERT_EQ(map_got.begin()->first, "foo2");
- ASSERT_EQ(got3.size(), (unsigned)2);
- ASSERT_EQ(got3.begin()->first, "foo");
- ASSERT_EQ(got3.rbegin()->first, "qfoo3");
- ASSERT_EQ(got4.size(), (unsigned)1);
- ASSERT_EQ(got4.begin()->first, "qfoo3");
- }
-
- {
- boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0, 0));
- ObjectWriteOperation op;
- set<string> to_remove;
- to_remove.insert("foo2");
- op.omap_rm_keys(to_remove);
- ioctx.aio_operate("test_obj", my_completion.get(), &op);
- {
- TestAlarm alarm;
- ASSERT_EQ(0, my_completion->wait_for_complete());
- }
- }
-
- {
- boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0, 0));
- ObjectReadOperation op;
-
- set<string> set_got;
- op.omap_get_keys("", -1, &set_got, 0);
- ioctx.aio_operate("test_obj", my_completion.get(), &op, 0);
- {
- TestAlarm alarm;
- ASSERT_EQ(0, my_completion->wait_for_complete());
- }
- ASSERT_EQ(set_got.size(), (unsigned)2);
- }
-
- {
- boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0, 0));
- ObjectWriteOperation op;
- op.omap_clear();
- ioctx.aio_operate("test_obj", my_completion.get(), &op);
- {
- TestAlarm alarm;
- ASSERT_EQ(0, my_completion->wait_for_complete());
- }
- }
-
- {
- boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0, 0));
- ObjectReadOperation op;
-
- set<string> set_got;
- op.omap_get_keys("", -1, &set_got, 0);
- ioctx.aio_operate("test_obj", my_completion.get(), &op, 0);
- {
- TestAlarm alarm;
- ASSERT_EQ(0, my_completion->wait_for_complete());
- }
- ASSERT_EQ(set_got.size(), (unsigned)0);
- }
-
- ioctx.remove("test_obj");
-}
+++ /dev/null
-#include "include/rados/librados.h"
-#include "include/rados/librados.hpp"
-#include "test/rados-api/test.h"
-
-#include "gtest/gtest.h"
-#include <errno.h>
-#include <map>
-#include <sstream>
-#include <string>
-
-using namespace librados;
-using ceph::buffer;
-using std::map;
-using std::ostringstream;
-using std::string;
-
-TEST(LibRadosCls, DNE) {
- Rados cluster;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- IoCtx ioctx;
- cluster.ioctx_create(pool_name.c_str(), ioctx);
-
- // create an object
- string oid = "foo";
- bufferlist bl;
- ASSERT_EQ(0, ioctx.write(oid, bl, bl.length(), 0));
-
- // call a bogus class
- ASSERT_EQ(-EOPNOTSUPP, ioctx.exec(oid, "doesnotexistasdfasdf", "method", bl, bl));
-
- // call a bogus method on existent class
- ASSERT_EQ(-EOPNOTSUPP, ioctx.exec(oid, "lock", "doesnotexistasdfasdfasdf", bl, bl));
-
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
+++ /dev/null
-#include "include/rados/librados.h"
-#include "include/rados/librados.hpp"
-#include "test/rados-api/test.h"
-
-#include <errno.h>
-#include "gtest/gtest.h"
-
-using namespace librados;
-using std::string;
-
-TEST(LibRadosIo, SimpleWrite) {
- char buf[128];
- rados_t cluster;
- rados_ioctx_t ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
- memset(buf, 0xcc, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
- rados_ioctx_destroy(ioctx);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosIo, SimpleWritePP) {
- char buf[128];
- std::string pool_name = get_temp_pool_name();
- Rados cluster;
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- IoCtx ioctx;
- cluster.ioctx_create(pool_name.c_str(), ioctx);
- memset(buf, 0xcc, sizeof(buf));
- bufferlist bl;
- bl.append(buf, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl, sizeof(buf), 0));
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
-
-TEST(LibRadosIo, RoundTrip) {
- char buf[128];
- char buf2[128];
- rados_t cluster;
- rados_ioctx_t ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
- memset(buf, 0xcc, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
- memset(buf2, 0, sizeof(buf2));
- ASSERT_EQ((int)sizeof(buf2), rados_read(ioctx, "foo", buf2, sizeof(buf2), 0));
- ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf)));
- rados_ioctx_destroy(ioctx);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosIo, RoundTripPP) {
- char buf[128];
- char buf2[128];
- Rados cluster;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- IoCtx ioctx;
- cluster.ioctx_create(pool_name.c_str(), ioctx);
- memset(buf, 0xcc, sizeof(buf));
- bufferlist bl;
- bl.append(buf, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl, sizeof(buf), 0));
- bufferlist cl;
- ASSERT_EQ((int)sizeof(buf2), ioctx.read("foo", cl, sizeof(buf), 0));
- ASSERT_EQ(0, memcmp(buf, cl.c_str(), sizeof(buf)));
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
-
-TEST(LibRadosIo, OverlappingWriteRoundTrip) {
- char buf[128];
- char buf2[64];
- char buf3[128];
- rados_t cluster;
- rados_ioctx_t ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
- memset(buf, 0xcc, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
- memset(buf2, 0xdd, sizeof(buf2));
- ASSERT_EQ((int)sizeof(buf2), rados_write(ioctx, "foo", buf2, sizeof(buf2), 0));
- memset(buf3, 0xdd, sizeof(buf3));
- ASSERT_EQ((int)sizeof(buf3), rados_read(ioctx, "foo", buf3, sizeof(buf3), 0));
- ASSERT_EQ(0, memcmp(buf3, buf2, sizeof(buf2)));
- ASSERT_EQ(0, memcmp(buf3 + sizeof(buf2), buf, sizeof(buf) - sizeof(buf2)));
- rados_ioctx_destroy(ioctx);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosIo, OverlappingWriteRoundTripPP) {
- char buf[128];
- char buf2[64];
- Rados cluster;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- IoCtx ioctx;
- cluster.ioctx_create(pool_name.c_str(), ioctx);
- memset(buf, 0xcc, sizeof(buf));
- bufferlist bl1;
- bl1.append(buf, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl1, sizeof(buf), 0));
- memset(buf2, 0xdd, sizeof(buf2));
- bufferlist bl2;
- bl2.append(buf2, sizeof(buf2));
- ASSERT_EQ((int)sizeof(buf2), ioctx.write("foo", bl2, sizeof(buf2), 0));
- bufferlist bl3;
- ASSERT_EQ((int)sizeof(buf), ioctx.read("foo", bl3, sizeof(buf), 0));
- ASSERT_EQ(0, memcmp(bl3.c_str(), buf2, sizeof(buf2)));
- ASSERT_EQ(0, memcmp(bl3.c_str() + sizeof(buf2), buf, sizeof(buf) - sizeof(buf2)));
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
-
-TEST(LibRadosIo, WriteFullRoundTrip) {
- char buf[128];
- char buf2[64];
- char buf3[128];
- rados_t cluster;
- rados_ioctx_t ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
- memset(buf, 0xcc, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
- memset(buf2, 0xdd, sizeof(buf2));
- ASSERT_EQ(0, rados_write_full(ioctx, "foo", buf2, sizeof(buf2)));
- memset(buf3, 0xdd, sizeof(buf3));
- ASSERT_EQ((int)sizeof(buf2), rados_read(ioctx, "foo", buf3, sizeof(buf3), 0));
- ASSERT_EQ(0, memcmp(buf2, buf2, sizeof(buf2)));
- rados_ioctx_destroy(ioctx);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosIo, WriteFullRoundTripPP) {
- char buf[128];
- char buf2[64];
- Rados cluster;
- IoCtx ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- cluster.ioctx_create(pool_name.c_str(), ioctx);
- memset(buf, 0xcc, sizeof(buf));
- bufferlist bl1;
- bl1.append(buf, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl1, sizeof(buf), 0));
- memset(buf2, 0xdd, sizeof(buf2));
- bufferlist bl2;
- bl2.append(buf2, sizeof(buf2));
- ASSERT_EQ(0, ioctx.write_full("foo", bl2));
- bufferlist bl3;
- ASSERT_EQ((int)sizeof(buf2), ioctx.read("foo", bl3, sizeof(buf), 0));
- ASSERT_EQ(0, memcmp(bl3.c_str(), buf2, sizeof(buf2)));
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
-
-TEST(LibRadosIo, AppendRoundTrip) {
- char buf[64];
- char buf2[64];
- char buf3[sizeof(buf) + sizeof(buf2)];
- rados_t cluster;
- rados_ioctx_t ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
- memset(buf, 0xde, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), rados_append(ioctx, "foo", buf, sizeof(buf)));
- memset(buf2, 0xad, sizeof(buf2));
- ASSERT_EQ((int)sizeof(buf2), rados_append(ioctx, "foo", buf2, sizeof(buf2)));
- memset(buf3, 0, sizeof(buf3));
- ASSERT_EQ((int)sizeof(buf3), rados_read(ioctx, "foo", buf3, sizeof(buf3), 0));
- ASSERT_EQ(0, memcmp(buf3, buf, sizeof(buf)));
- ASSERT_EQ(0, memcmp(buf3 + sizeof(buf), buf2, sizeof(buf2)));
- rados_ioctx_destroy(ioctx);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosIo, AppendRoundTripPP) {
- char buf[64];
- char buf2[64];
- Rados cluster;
- IoCtx ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- cluster.ioctx_create(pool_name.c_str(), ioctx);
- memset(buf, 0xde, sizeof(buf));
- bufferlist bl1;
- bl1.append(buf, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), ioctx.append("foo", bl1, sizeof(buf)));
- memset(buf2, 0xad, sizeof(buf2));
- bufferlist bl2;
- bl2.append(buf2, sizeof(buf2));
- ASSERT_EQ((int)sizeof(buf2), ioctx.append("foo", bl2, sizeof(buf2)));
- bufferlist bl3;
- ASSERT_EQ((int)(sizeof(buf) + sizeof(buf2)),
- ioctx.read("foo", bl3, (sizeof(buf) + sizeof(buf2)), 0));
- const char *bl3_str = bl3.c_str();
- ASSERT_EQ(0, memcmp(bl3_str, buf, sizeof(buf)));
- ASSERT_EQ(0, memcmp(bl3_str + sizeof(buf), buf2, sizeof(buf2)));
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
-
-TEST(LibRadosIo, TruncTest) {
- char buf[128];
- char buf2[sizeof(buf)];
- rados_t cluster;
- rados_ioctx_t ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
- memset(buf, 0xaa, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), rados_append(ioctx, "foo", buf, sizeof(buf)));
- ASSERT_EQ(0, rados_trunc(ioctx, "foo", sizeof(buf) / 2));
- memset(buf2, 0, sizeof(buf2));
- ASSERT_EQ((int)(sizeof(buf)/2), rados_read(ioctx, "foo", buf2, sizeof(buf2), 0));
- ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf)/2));
- rados_ioctx_destroy(ioctx);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosIo, TruncTestPP) {
- char buf[128];
- Rados cluster;
- IoCtx ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- cluster.ioctx_create(pool_name.c_str(), ioctx);
- memset(buf, 0xaa, sizeof(buf));
- bufferlist bl;
- bl.append(buf, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), ioctx.append("foo", bl, sizeof(buf)));
- ASSERT_EQ(0, ioctx.trunc("foo", sizeof(buf) / 2));
- bufferlist bl2;
- ASSERT_EQ((int)(sizeof(buf)/2), ioctx.read("foo", bl2, sizeof(buf), 0));
- ASSERT_EQ(0, memcmp(bl2.c_str(), buf, sizeof(buf)/2));
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
-
-TEST(LibRadosIo, RemoveTest) {
- char buf[128];
- char buf2[sizeof(buf)];
- rados_t cluster;
- rados_ioctx_t ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
- memset(buf, 0xaa, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), rados_append(ioctx, "foo", buf, sizeof(buf)));
- ASSERT_EQ(0, rados_remove(ioctx, "foo"));
- memset(buf2, 0, sizeof(buf2));
- ASSERT_EQ(-ENOENT, rados_read(ioctx, "foo", buf2, sizeof(buf2), 0));
- rados_ioctx_destroy(ioctx);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosIo, RemoveTestPP) {
- char buf[128];
- Rados cluster;
- IoCtx ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- cluster.ioctx_create(pool_name.c_str(), ioctx);
- memset(buf, 0xaa, sizeof(buf));
- bufferlist bl1;
- bl1.append(buf, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), ioctx.append("foo", bl1, sizeof(buf)));
- ASSERT_EQ(0, ioctx.remove("foo"));
- bufferlist bl2;
- ASSERT_EQ(-ENOENT, ioctx.read("foo", bl2, sizeof(buf), 0));
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
-
-TEST(LibRadosIo, XattrsRoundTrip) {
- char buf[128];
- char attr1[] = "attr1";
- char attr1_buf[] = "foo bar baz";
- rados_t cluster;
- rados_ioctx_t ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
- memset(buf, 0xaa, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), rados_append(ioctx, "foo", buf, sizeof(buf)));
- ASSERT_EQ(-ENODATA, rados_getxattr(ioctx, "foo", attr1, buf, sizeof(buf)));
- ASSERT_EQ(0, rados_setxattr(ioctx, "foo", attr1, attr1_buf, sizeof(attr1_buf)));
- ASSERT_EQ((int)sizeof(attr1_buf),
- rados_getxattr(ioctx, "foo", attr1, buf, sizeof(buf)));
- ASSERT_EQ(0, memcmp(attr1_buf, buf, sizeof(attr1_buf)));
- rados_ioctx_destroy(ioctx);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosIo, XattrsRoundTripPP) {
- char buf[128];
- char attr1[] = "attr1";
- char attr1_buf[] = "foo bar baz";
- Rados cluster;
- IoCtx ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- cluster.ioctx_create(pool_name.c_str(), ioctx);
- memset(buf, 0xaa, sizeof(buf));
- bufferlist bl1;
- bl1.append(buf, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), ioctx.append("foo", bl1, sizeof(buf)));
- bufferlist bl2;
- ASSERT_EQ(-ENODATA, ioctx.getxattr("foo", attr1, bl2));
- bufferlist bl3;
- bl3.append(attr1_buf, sizeof(attr1_buf));
- ASSERT_EQ(0, ioctx.setxattr("foo", attr1, bl3));
- bufferlist bl4;
- ASSERT_EQ((int)sizeof(attr1_buf),
- ioctx.getxattr("foo", attr1, bl4));
- ASSERT_EQ(0, memcmp(bl4.c_str(), attr1_buf, sizeof(attr1_buf)));
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
-
-TEST(LibRadosIo, RmXattr) {
- char buf[128];
- char attr1[] = "attr1";
- char attr1_buf[] = "foo bar baz";
- rados_t cluster;
- rados_ioctx_t ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
- memset(buf, 0xaa, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), rados_append(ioctx, "foo", buf, sizeof(buf)));
- ASSERT_EQ(0,
- rados_setxattr(ioctx, "foo", attr1, attr1_buf, sizeof(attr1_buf)));
- ASSERT_EQ(0, rados_rmxattr(ioctx, "foo", attr1));
- ASSERT_EQ(-ENODATA, rados_getxattr(ioctx, "foo", attr1, buf, sizeof(buf)));
- rados_ioctx_destroy(ioctx);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosIo, RmXattrPP) {
- char buf[128];
- char attr1[] = "attr1";
- char attr1_buf[] = "foo bar baz";
- Rados cluster;
- IoCtx ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- cluster.ioctx_create(pool_name.c_str(), ioctx);
- memset(buf, 0xaa, sizeof(buf));
- bufferlist bl1;
- bl1.append(buf, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), ioctx.append("foo", bl1, sizeof(buf)));
- bufferlist bl2;
- bl2.append(attr1_buf, sizeof(attr1_buf));
- ASSERT_EQ(0, ioctx.setxattr("foo", attr1, bl2));
- ASSERT_EQ(0, ioctx.rmxattr("foo", attr1));
- bufferlist bl3;
- ASSERT_EQ(-ENODATA, ioctx.getxattr("foo", attr1, bl3));
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
-
-TEST(LibRadosIo, XattrIter) {
- char buf[128];
- char attr1[] = "attr1";
- char attr1_buf[] = "foo bar baz";
- char attr2[] = "attr2";
- char attr2_buf[256];
- for (size_t j = 0; j < sizeof(attr2_buf); ++j) {
- attr2_buf[j] = j % 0xff;
- }
- rados_t cluster;
- rados_ioctx_t ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
- memset(buf, 0xaa, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), rados_append(ioctx, "foo", buf, sizeof(buf)));
- ASSERT_EQ(0, rados_setxattr(ioctx, "foo", attr1, attr1_buf, sizeof(attr1_buf)));
- ASSERT_EQ(0, rados_setxattr(ioctx, "foo", attr2, attr2_buf, sizeof(attr2_buf)));
- rados_xattrs_iter_t iter;
- ASSERT_EQ(0, rados_getxattrs(ioctx, "foo", &iter));
- int num_seen = 0;
- while (true) {
- const char *name;
- const char *val;
- size_t len;
- ASSERT_EQ(0, rados_getxattrs_next(iter, &name, &val, &len));
- if (name == NULL) {
- break;
- }
- ASSERT_LT(num_seen, 2);
- if ((strcmp(name, attr1) == 0) && (memcmp(val, attr1_buf, len) == 0)) {
- num_seen++;
- continue;
- }
- else if ((strcmp(name, attr2) == 0) && (memcmp(val, attr2_buf, len) == 0)) {
- num_seen++;
- continue;
- }
- else {
- ASSERT_EQ(0, 1);
- }
- }
- rados_getxattrs_end(iter);
- rados_ioctx_destroy(ioctx);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosIo, XattrListPP) {
- char buf[128];
- char attr1[] = "attr1";
- char attr1_buf[] = "foo bar baz";
- char attr2[] = "attr2";
- char attr2_buf[256];
- for (size_t j = 0; j < sizeof(attr2_buf); ++j) {
- attr2_buf[j] = j % 0xff;
- }
- Rados cluster;
- IoCtx ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- cluster.ioctx_create(pool_name.c_str(), ioctx);
- memset(buf, 0xaa, sizeof(buf));
- bufferlist bl1;
- bl1.append(buf, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), ioctx.append("foo", bl1, sizeof(buf)));
- bufferlist bl2;
- bl2.append(attr1_buf, sizeof(attr1_buf));
- ASSERT_EQ(0, ioctx.setxattr("foo", attr1, bl2));
- bufferlist bl3;
- bl3.append(attr2_buf, sizeof(attr2_buf));
- ASSERT_EQ(0, ioctx.setxattr("foo", attr2, bl3));
- std::map<std::string, bufferlist> attrset;
- ASSERT_EQ(0, ioctx.getxattrs("foo", attrset));
- for (std::map<std::string, bufferlist>::iterator i = attrset.begin();
- i != attrset.end(); ++i) {
- if (i->first == string(attr1)) {
- ASSERT_EQ(0, memcmp(i->second.c_str(), attr1_buf, sizeof(attr1_buf)));
- }
- else if (i->first == string(attr2)) {
- ASSERT_EQ(0, memcmp(i->second.c_str(), attr2_buf, sizeof(attr2_buf)));
- }
- else {
- ASSERT_EQ(0, 1);
- }
- }
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
+++ /dev/null
-#include "include/rados/librados.h"
-#include "include/rados/librados.hpp"
-#include "test/rados-api/test.h"
-
-#include "gtest/gtest.h"
-#include <errno.h>
-#include <string>
-
-using namespace librados;
-
-TEST(LibRadosList, ListObjects) {
- char buf[128];
- rados_t cluster;
- rados_ioctx_t ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
- memset(buf, 0xcc, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
- rados_list_ctx_t ctx;
- ASSERT_EQ(0, rados_objects_list_open(ioctx, &ctx));
- const char *entry;
- ASSERT_EQ(0, rados_objects_list_next(ctx, &entry, NULL));
- ASSERT_EQ(std::string(entry), "foo");
- ASSERT_EQ(-ENOENT, rados_objects_list_next(ctx, &entry, NULL));
- rados_objects_list_close(ctx);
- rados_ioctx_destroy(ioctx);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosList, ListObjectsPP) {
- std::string pool_name = get_temp_pool_name();
- Rados cluster;
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- IoCtx ioctx;
- cluster.ioctx_create(pool_name.c_str(), ioctx);
- char buf[128];
- memset(buf, 0xcc, sizeof(buf));
- bufferlist bl1;
- bl1.append(buf, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl1, sizeof(buf), 0));
- ObjectIterator iter(ioctx.objects_begin());
- ASSERT_EQ((iter == ioctx.objects_end()), false);
- ASSERT_EQ((*iter).first, "foo");
- ++iter;
- ASSERT_EQ(true, (iter == ioctx.objects_end()));
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
+++ /dev/null
-#include "mds/mdstypes.h"
-#include "include/buffer.h"
-#include "include/rbd_types.h"
-#include "include/rados/librados.h"
-#include "include/rados/librados.hpp"
-#include "test/rados-api/test.h"
-
-#include "gtest/gtest.h"
-#include <errno.h>
-#include <map>
-#include <sstream>
-#include <string>
-
-using namespace librados;
-using ceph::buffer;
-using std::map;
-using std::ostringstream;
-using std::string;
-
-TEST(LibRadosMisc, Version) {
- int major, minor, extra;
- rados_version(&major, &minor, &extra);
-}
-
-TEST(LibRadosMisc, VersionPP) {
- int major, minor, extra;
- Rados::version(&major, &minor, &extra);
-}
-
-TEST(LibRadosMisc, ClusterFSID) {
- rados_t cluster;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
-
- char fsid[37];
- ASSERT_EQ(-ERANGE, rados_cluster_fsid(cluster, fsid, sizeof(fsid) - 1));
- ASSERT_EQ(sizeof(fsid) - 1,
- (size_t)rados_cluster_fsid(cluster, fsid, sizeof(fsid)));
-
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-static std::string read_key_from_tmap(IoCtx& ioctx, const std::string &obj,
- const std::string &key)
-{
- bufferlist bl;
- int r = ioctx.read(obj, bl, 0, 0);
- if (r <= 0) {
- ostringstream oss;
- oss << "ioctx.read(" << obj << ", bl, 0, 0) returned " << r;
- return oss.str();
- }
- bufferlist::iterator p = bl.begin();
- bufferlist header;
- map<string, bufferlist> m;
- ::decode(header, p);
- ::decode(m, p);
- map<string, bufferlist>::iterator i = m.find(key);
- if (i == m.end())
- return "";
- std::string retstring;
- ::decode(retstring, i->second);
- return retstring;
-}
-
-static std::string add_key_to_tmap(IoCtx &ioctx, const std::string &obj,
- const std::string &key, const std::string &val)
-{
- __u8 c = CEPH_OSD_TMAP_SET;
-
- bufferlist tmbl;
- ::encode(c, tmbl);
- ::encode(key, tmbl);
- bufferlist blbl;
- ::encode(val, blbl);
- ::encode(blbl, tmbl);
- int ret = ioctx.tmap_update(obj, tmbl);
- if (ret) {
- ostringstream oss;
- oss << "ioctx.tmap_update(obj=" << obj << ", key="
- << key << ", val=" << val << ") failed with error " << ret;
- return oss.str();
- }
- return "";
-}
-
-static int remove_key_from_tmap(IoCtx &ioctx, const std::string &obj,
- const std::string &key)
-{
- __u8 c = CEPH_OSD_TMAP_RM;
-
- bufferlist tmbl;
- ::encode(c, tmbl);
- ::encode(key, tmbl);
- int ret = ioctx.tmap_update(obj, tmbl);
- if (ret) {
- ostringstream oss;
- oss << "ioctx.tmap_update(obj=" << obj << ", key="
- << key << ") failed with error " << ret;
- }
- return ret;
-}
-
-TEST(LibRadosMisc, TmapUpdatePP) {
- Rados cluster;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- IoCtx ioctx;
- cluster.ioctx_create(pool_name.c_str(), ioctx);
-
- // create tmap
- {
- __u8 c = CEPH_OSD_TMAP_CREATE;
- std::string my_tmap("my_tmap");
- bufferlist emptybl;
-
- bufferlist tmbl;
- ::encode(c, tmbl);
- ::encode(my_tmap, tmbl);
- ::encode(emptybl, tmbl);
- ASSERT_EQ(0, ioctx.tmap_update("foo", tmbl));
- }
-
- ASSERT_EQ(string(""), add_key_to_tmap(ioctx, "foo", "key1", "val1"));
-
- ASSERT_EQ(string(""), add_key_to_tmap(ioctx, "foo", "key2", "val2"));
-
- // read key1 from the tmap
- ASSERT_EQ(string("val1"), read_key_from_tmap(ioctx, "foo", "key1"));
-
- // remove key1 from tmap
- ASSERT_EQ(0, remove_key_from_tmap(ioctx, "foo", "key1"));
- ASSERT_EQ(-ENOENT, remove_key_from_tmap(ioctx, "foo", "key1"));
-
- // key should be removed
- ASSERT_EQ(string(""), read_key_from_tmap(ioctx, "foo", "key1"));
-
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
-
-TEST(LibRadosMisc, Exec) {
- char buf[128];
- rados_t cluster;
- rados_ioctx_t ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
- memset(buf, 0xcc, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
- char buf2[512];
- int res = rados_exec(ioctx, "foo", "rbd", "get_all_features",
- NULL, 0, buf2, sizeof(buf2));
- ASSERT_GT(res, 0);
- bufferlist bl;
- bl.append(buf2, res);
- bufferlist::iterator iter = bl.begin();
- uint64_t all_features;
- ::decode(all_features, iter);
- ASSERT_EQ(all_features, (uint64_t)RBD_FEATURES_ALL);
- rados_ioctx_destroy(ioctx);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosMisc, ExecPP) {
- Rados cluster;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- IoCtx ioctx;
- cluster.ioctx_create(pool_name.c_str(), ioctx);
- bufferlist bl;
- ASSERT_EQ(0, ioctx.write("foo", bl, 0, 0));
- bufferlist bl2, out;
- int r = ioctx.exec("foo", "rbd", "get_all_features", bl2, out);
- ASSERT_EQ(0, r);
- bufferlist::iterator iter = out.begin();
- uint64_t all_features;
- ::decode(all_features, iter);
- ASSERT_EQ(all_features, (uint64_t)RBD_FEATURES_ALL);
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
-
-TEST(LibRadosMisc, Operate1PP) {
- Rados cluster;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- IoCtx ioctx;
- cluster.ioctx_create(pool_name.c_str(), ioctx);
-
- ObjectWriteOperation o;
- {
- bufferlist bl;
- o.write(0, bl);
- }
- std::string val1("val1");
- {
- bufferlist bl;
- bl.append(val1.c_str(), val1.size() + 1);
- o.setxattr("key1", bl);
- }
- ASSERT_EQ(0, ioctx.operate("foo", &o));
- {
- bufferlist bl;
- ASSERT_GT(ioctx.getxattr("foo", "key1", bl), 0);
- ASSERT_EQ(0, strcmp(bl.c_str(), val1.c_str()));
- }
- ObjectWriteOperation o2;
- {
- bufferlist bl;
- bl.append(val1);
- o2.cmpxattr("key1", CEPH_OSD_CMPXATTR_OP_EQ, bl);
- o2.rmxattr("key1");
- }
- ASSERT_EQ(0, ioctx.operate("foo", &o2));
- ObjectWriteOperation o3;
- {
- bufferlist bl;
- bl.append(val1);
- o3.cmpxattr("key1", CEPH_OSD_CMPXATTR_OP_EQ, bl);
- }
- ASSERT_LT(ioctx.operate("foo", &o3), 0);
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
-
-TEST(LibRadosMisc, Operate2PP) {
- Rados cluster;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- IoCtx ioctx;
- cluster.ioctx_create(pool_name.c_str(), ioctx);
-
- ObjectWriteOperation o;
- {
- bufferlist bl;
- bl.append("abcdefg");
- o.write(0, bl);
- }
- std::string val1("val1");
- {
- bufferlist bl;
- bl.append(val1.c_str(), val1.size() + 1);
- o.setxattr("key1", bl);
- o.truncate(0);
- }
- ASSERT_EQ(0, ioctx.operate("foo", &o));
- uint64_t size;
- time_t mtime;
- ASSERT_EQ(0, ioctx.stat("foo", &size, &mtime));
- ASSERT_EQ(0U, size);
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
-
-void set_completion_complete(rados_completion_t cb, void *arg)
-{
- bool *my_aio_complete = (bool*)arg;
- *my_aio_complete = true;
-}
-
-TEST(LibRadosMisc, AioOperatePP) {
- Rados cluster;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- IoCtx ioctx;
- cluster.ioctx_create(pool_name.c_str(), ioctx);
-
- bool my_aio_complete = false;
- AioCompletion *my_completion = cluster.aio_create_completion(
- (void*)&my_aio_complete, set_completion_complete, NULL);
- AioCompletion *my_completion_null = NULL;
- ASSERT_NE(my_completion, my_completion_null);
-
- ObjectWriteOperation o;
- {
- bufferlist bl;
- o.write(0, bl);
- }
- std::string val1("val1");
- {
- bufferlist bl;
- bl.append(val1.c_str(), val1.size() + 1);
- o.setxattr("key1", bl);
- bufferlist bl2;
- char buf2[1024];
- memset(buf2, 0xdd, sizeof(buf2));
- bl2.append(buf2, sizeof(buf2));
- o.append(bl2);
- }
- ASSERT_EQ(0, ioctx.aio_operate("foo", my_completion, &o));
- ASSERT_EQ(0, my_completion->wait_for_complete_and_cb());
- ASSERT_EQ(my_aio_complete, true);
-
- uint64_t size;
- time_t mtime;
- ASSERT_EQ(0, ioctx.stat("foo", &size, &mtime));
- ASSERT_EQ(1024U, size);
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
-
-TEST(LibRadosMisc, CloneRangePP) {
- Rados cluster;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- IoCtx ioctx;
- ASSERT_EQ(0, cluster.ioctx_create(pool_name.c_str(), ioctx));
- char buf[64];
- memset(buf, 0xcc, sizeof(buf));
- bufferlist bl;
- bl.append(buf, sizeof(buf));
- ASSERT_EQ(sizeof(buf), (size_t)ioctx.write("foo", bl, sizeof(buf), 0));
- ioctx.locator_set_key("foo");
- ASSERT_EQ(0, ioctx.clone_range("bar", 0, "foo", 0, sizeof(buf)));
- bufferlist bl2;
- ASSERT_EQ(sizeof(buf), (size_t)ioctx.read("bar", bl2, sizeof(buf), 0));
- ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf)));
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
-
-TEST(LibRadosMisc, CloneRange) {
- char buf[128];
- rados_t cluster;
- rados_ioctx_t ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
- memset(buf, 0xcc, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "src", buf, sizeof(buf), 0));
- rados_ioctx_locator_set_key(ioctx, "src");
- ASSERT_EQ(0, rados_clone_range(ioctx, "dst", 0, "src", 0, sizeof(buf)));
- char buf2[sizeof(buf)];
- memset(buf2, 0, sizeof(buf2));
- ASSERT_EQ((int)sizeof(buf2), rados_read(ioctx, "dst", buf2, sizeof(buf2), 0));
- ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf)));
- rados_ioctx_destroy(ioctx);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosMisc, AssertExistsPP) {
- Rados cluster;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- IoCtx ioctx;
- ASSERT_EQ(0, cluster.ioctx_create(pool_name.c_str(), ioctx));
-
- char buf[64];
- memset(buf, 0xcc, sizeof(buf));
- bufferlist bl;
- bl.append(buf, sizeof(buf));
-
- ObjectWriteOperation op;
- op.assert_exists();
- op.write(0, bl);
- ASSERT_EQ(-ENOENT, ioctx.operate("asdffoo", &op));
- ASSERT_EQ(0, ioctx.create("asdffoo", true));
- ASSERT_EQ(0, ioctx.operate("asdffoo", &op));
- ASSERT_EQ(-EEXIST, ioctx.create("asdffoo", true));
-
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
+++ /dev/null
-#include "include/rados/librados.h"
-#include "test/rados-api/test.h"
-
-#include "gtest/gtest.h"
-#include <errno.h>
-#include <vector>
-
-#define POOL_LIST_BUF_SZ 32768
-
-TEST(LibRadosPools, PoolList) {
- std::vector<char> pool_list_buf(POOL_LIST_BUF_SZ, '\0');
- char *buf = &pool_list_buf[0];
- rados_t cluster;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- ASSERT_LT(rados_pool_list(cluster, buf, POOL_LIST_BUF_SZ), POOL_LIST_BUF_SZ);
-
- bool found_pool = false;
- while (buf[0] != '\0') {
- if ((found_pool == false) && (strcmp(buf, pool_name.c_str()) == 0)) {
- found_pool = true;
- }
- buf += strlen(buf) + 1;
- }
- ASSERT_EQ(found_pool, true);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-int64_t rados_pool_lookup(rados_t cluster, const char *pool_name);
-
-TEST(LibRadosPools, PoolLookup) {
- rados_t cluster;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- ASSERT_LT(0, rados_pool_lookup(cluster, pool_name.c_str()));
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosPools, PoolLookup2) {
- rados_t cluster;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- int64_t pool_id = rados_pool_lookup(cluster, pool_name.c_str());
- ASSERT_GT(pool_id, 0);
- rados_ioctx_t ioctx;
- ASSERT_EQ(0, rados_ioctx_create(cluster, pool_name.c_str(), &ioctx));
- int64_t pool_id2 = rados_ioctx_get_id(ioctx);
- ASSERT_EQ(pool_id, pool_id2);
- rados_ioctx_destroy(ioctx);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosPools, PoolDelete) {
- rados_t cluster;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- ASSERT_EQ(0, rados_pool_delete(cluster, pool_name.c_str()));
- ASSERT_GT(0, rados_pool_lookup(cluster, pool_name.c_str()));
- ASSERT_EQ(0, rados_pool_create(cluster, pool_name.c_str()));
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosPools, PoolCreateDelete) {
- rados_t cluster;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
-
- std::string n = pool_name + "abc123";
- ASSERT_EQ(0, rados_pool_create(cluster, n.c_str()));
- ASSERT_EQ(-EEXIST, rados_pool_create(cluster, n.c_str()));
- ASSERT_EQ(0, rados_pool_delete(cluster, n.c_str()));
- ASSERT_EQ(-ENOENT, rados_pool_delete(cluster, n.c_str()));
-
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosPools, AuidTest1) {
- rados_t cluster;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- rados_ioctx_t ioctx;
- ASSERT_EQ(0, rados_ioctx_create(cluster, pool_name.c_str(), &ioctx));
- ASSERT_EQ(0, rados_ioctx_pool_set_auid(ioctx, 123));
- uint64_t auid;
- ASSERT_EQ(0, rados_ioctx_pool_get_auid(ioctx, &auid));
- ASSERT_EQ(123ull, auid);
- rados_ioctx_destroy(ioctx);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosPools, AuidTest2) {
- rados_t cluster;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- ASSERT_EQ(0, rados_pool_delete(cluster, pool_name.c_str()));
- ASSERT_EQ(0, rados_pool_create_with_auid(cluster, pool_name.c_str(), 456));
- rados_ioctx_t ioctx;
- ASSERT_EQ(0, rados_ioctx_create(cluster, pool_name.c_str(), &ioctx));
- uint64_t auid;
- ASSERT_EQ(0, rados_ioctx_pool_get_auid(ioctx, &auid));
- ASSERT_EQ(456ull, auid);
- rados_ioctx_destroy(ioctx);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosPools, PoolCreateWithCrushRule) {
- rados_t cluster;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
-
- std::string pool2_name = get_temp_pool_name();
- ASSERT_EQ(0, rados_pool_create_with_crush_rule(cluster,
- pool2_name.c_str(), 0));
- ASSERT_EQ(0, rados_pool_delete(cluster, pool2_name.c_str()));
-
- std::string pool3_name = get_temp_pool_name();
- ASSERT_EQ(0, rados_pool_create_with_all(cluster, pool3_name.c_str(),
- 456ull, 0));
- rados_ioctx_t ioctx;
- ASSERT_EQ(0, rados_ioctx_create(cluster, pool3_name.c_str(), &ioctx));
- uint64_t auid;
- ASSERT_EQ(0, rados_ioctx_pool_get_auid(ioctx, &auid));
- ASSERT_EQ(456ull, auid);
- ASSERT_EQ(0, rados_pool_delete(cluster, pool3_name.c_str()));
- rados_ioctx_destroy(ioctx);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
+++ /dev/null
-#include "include/rados/librados.h"
-#include "test/rados-api/test.h"
-
-#include <algorithm>
-#include <errno.h>
-#include "gtest/gtest.h"
-#include <string>
-
-using namespace librados;
-using std::string;
-
-TEST(LibRadosSnapshots, SnapList) {
- char buf[128];
- rados_t cluster;
- rados_ioctx_t ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
- memset(buf, 0xcc, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
- ASSERT_EQ(0, rados_ioctx_snap_create(ioctx, "snap1"));
- rados_snap_t snaps[10];
- ASSERT_EQ(1, rados_ioctx_snap_list(ioctx, snaps,
- sizeof(snaps) / sizeof(snaps[0])));
- rados_snap_t rid;
- ASSERT_EQ(0, rados_ioctx_snap_lookup(ioctx, "snap1", &rid));
- ASSERT_EQ(rid, snaps[0]);
- rados_ioctx_destroy(ioctx);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosSnapshots, SnapListPP) {
- Rados cluster;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- IoCtx ioctx;
- cluster.ioctx_create(pool_name.c_str(), ioctx);
- char buf[128];
- memset(buf, 0xcc, sizeof(buf));
- bufferlist bl1;
- bl1.append(buf, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl1, sizeof(buf), 0));
- ASSERT_EQ(0, ioctx.snap_create("snap1"));
- std::vector<snap_t> snaps;
- ASSERT_EQ(0, ioctx.snap_list(&snaps));
- ASSERT_EQ(1U, snaps.size());
- snap_t rid;
- ASSERT_EQ(0, ioctx.snap_lookup("snap1", &rid));
- ASSERT_EQ(rid, snaps[0]);
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
-
-TEST(LibRadosSnapshots, SnapRemove) {
- char buf[128];
- rados_t cluster;
- rados_ioctx_t ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
- memset(buf, 0xcc, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
- ASSERT_EQ(0, rados_ioctx_snap_create(ioctx, "snap1"));
- rados_snap_t rid;
- ASSERT_EQ(0, rados_ioctx_snap_lookup(ioctx, "snap1", &rid));
- ASSERT_EQ(-EEXIST, rados_ioctx_snap_create(ioctx, "snap1"));
- ASSERT_EQ(0, rados_ioctx_snap_remove(ioctx, "snap1"));
- ASSERT_EQ(-ENOENT, rados_ioctx_snap_lookup(ioctx, "snap1", &rid));
- rados_ioctx_destroy(ioctx);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosSnapshots, SnapRemovePP) {
- char buf[128];
- Rados cluster;
- IoCtx ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- cluster.ioctx_create(pool_name.c_str(), ioctx);
- memset(buf, 0xcc, sizeof(buf));
- bufferlist bl1;
- bl1.append(buf, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl1, sizeof(buf), 0));
- ASSERT_EQ(0, ioctx.snap_create("snap1"));
- rados_snap_t rid;
- ASSERT_EQ(0, ioctx.snap_lookup("snap1", &rid));
- ASSERT_EQ(0, ioctx.snap_remove("snap1"));
- ASSERT_EQ(-ENOENT, ioctx.snap_lookup("snap1", &rid));
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
-
-TEST(LibRadosSnapshots, Rollback) {
- char buf[128];
- rados_t cluster;
- rados_ioctx_t ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
- memset(buf, 0xcc, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
- ASSERT_EQ(0, rados_ioctx_snap_create(ioctx, "snap1"));
- char buf2[sizeof(buf)];
- memset(buf2, 0xdd, sizeof(buf2));
- ASSERT_EQ(0, rados_write_full(ioctx, "foo", buf2, sizeof(buf2)));
- ASSERT_EQ(0, rados_rollback(ioctx, "foo", "snap1"));
- char buf3[sizeof(buf)];
- ASSERT_EQ((int)sizeof(buf3), rados_read(ioctx, "foo", buf3, sizeof(buf3), 0));
- ASSERT_EQ(0, memcmp(buf, buf3, sizeof(buf)));
- rados_ioctx_destroy(ioctx);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosSnapshots, RollbackPP) {
- char buf[128];
- Rados cluster;
- IoCtx ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- cluster.ioctx_create(pool_name.c_str(), ioctx);
- memset(buf, 0xcc, sizeof(buf));
- bufferlist bl1;
- bl1.append(buf, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl1, sizeof(buf), 0));
- ASSERT_EQ(0, ioctx.snap_create("snap1"));
- char buf2[sizeof(buf)];
- memset(buf2, 0xdd, sizeof(buf2));
- bufferlist bl2;
- bl2.append(buf2, sizeof(buf2));
- ASSERT_EQ(0, ioctx.write_full("foo", bl2));
- ASSERT_EQ(0, ioctx.rollback("foo", "snap1"));
- bufferlist bl3;
- ASSERT_EQ((int)sizeof(buf), ioctx.read("foo", bl3, sizeof(buf), 0));
- ASSERT_EQ(0, memcmp(buf, bl3.c_str(), sizeof(buf)));
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
-
-TEST(LibRadosSnapshots, SnapGetName) {
- char buf[128];
- rados_t cluster;
- rados_ioctx_t ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
- memset(buf, 0xcc, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
- ASSERT_EQ(0, rados_ioctx_snap_create(ioctx, "snapfoo"));
- rados_snap_t rid;
- ASSERT_EQ(0, rados_ioctx_snap_lookup(ioctx, "snapfoo", &rid));
- ASSERT_EQ(-ENOENT, rados_ioctx_snap_lookup(ioctx, "snapbar", &rid));
- char name[128];
- memset(name, 0, sizeof(name));
- ASSERT_EQ(0, rados_ioctx_snap_get_name(ioctx, rid, name, sizeof(name)));
- time_t snaptime;
- ASSERT_EQ(0, rados_ioctx_snap_get_stamp(ioctx, rid, &snaptime));
- ASSERT_EQ(0, strcmp(name, "snapfoo"));
- rados_ioctx_destroy(ioctx);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosSnapshots, SnapGetNamePP) {
- char buf[128];
- Rados cluster;
- IoCtx ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- cluster.ioctx_create(pool_name.c_str(), ioctx);
- memset(buf, 0xcc, sizeof(buf));
- bufferlist bl;
- bl.append(buf, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl, sizeof(buf), 0));
- ASSERT_EQ(0, ioctx.snap_create("snapfoo"));
- rados_snap_t rid;
- ASSERT_EQ(0, ioctx.snap_lookup("snapfoo", &rid));
- ASSERT_EQ(-ENOENT, ioctx.snap_lookup("snapbar", &rid));
- std::string name;
- ASSERT_EQ(0, ioctx.snap_get_name(rid, &name));
- time_t snaptime;
- ASSERT_EQ(0, ioctx.snap_get_stamp(rid, &snaptime));
- ASSERT_EQ(0, strcmp(name.c_str(), "snapfoo"));
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
-
-TEST(LibRadosSnapshots, SelfManagedSnapTest) {
- std::vector<uint64_t> my_snaps;
- rados_t cluster;
- rados_ioctx_t ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- ASSERT_EQ(0, rados_ioctx_create(cluster, pool_name.c_str(), &ioctx));
-
- my_snaps.push_back(-2);
- ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_create(ioctx, &my_snaps.back()));
- ::std::reverse(my_snaps.begin(), my_snaps.end());
- ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_set_write_ctx(ioctx, my_snaps[0],
- &my_snaps[0], my_snaps.size()));
- ::std::reverse(my_snaps.begin(), my_snaps.end());
- char buf[128];
- memset(buf, 0xcc, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
-
- my_snaps.push_back(-2);
- ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_create(ioctx, &my_snaps.back()));
- ::std::reverse(my_snaps.begin(), my_snaps.end());
- ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_set_write_ctx(ioctx, my_snaps[0],
- &my_snaps[0], my_snaps.size()));
- ::std::reverse(my_snaps.begin(), my_snaps.end());
- char buf2[sizeof(buf)];
- memset(buf2, 0xdd, sizeof(buf2));
- ASSERT_EQ((int)sizeof(buf2), rados_write(ioctx, "foo", buf2, sizeof(buf2), 0));
- rados_ioctx_snap_set_read(ioctx, my_snaps[1]);
- char buf3[sizeof(buf)];
- ASSERT_EQ((int)sizeof(buf3), rados_read(ioctx, "foo", buf3, sizeof(buf3), 0));
- ASSERT_EQ(0, memcmp(buf3, buf, sizeof(buf)));
-
- ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_remove(ioctx, my_snaps.back()));
- my_snaps.pop_back();
- ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_remove(ioctx, my_snaps.back()));
- my_snaps.pop_back();
- rados_ioctx_destroy(ioctx);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosSnapshots, SelfManagedRollbackTest) {
- std::vector<uint64_t> my_snaps;
- rados_t cluster;
- rados_ioctx_t ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- ASSERT_EQ(0, rados_ioctx_create(cluster, pool_name.c_str(), &ioctx));
-
- my_snaps.push_back(-2);
- ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_create(ioctx, &my_snaps.back()));
- ::std::reverse(my_snaps.begin(), my_snaps.end());
- ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_set_write_ctx(ioctx, my_snaps[0],
- &my_snaps[0], my_snaps.size()));
- ::std::reverse(my_snaps.begin(), my_snaps.end());
- char buf[128];
- memset(buf, 0xcc, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
-
- my_snaps.push_back(-2);
- ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_create(ioctx, &my_snaps.back()));
- ::std::reverse(my_snaps.begin(), my_snaps.end());
- ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_set_write_ctx(ioctx, my_snaps[0],
- &my_snaps[0], my_snaps.size()));
- ::std::reverse(my_snaps.begin(), my_snaps.end());
- char buf2[sizeof(buf)];
- memset(buf2, 0xdd, sizeof(buf2));
- ASSERT_EQ((int)sizeof(buf2), rados_write(ioctx, "foo", buf2, sizeof(buf2), 0));
- rados_ioctx_selfmanaged_snap_rollback(ioctx, "foo", my_snaps[1]);
- char buf3[sizeof(buf)];
- ASSERT_EQ((int)sizeof(buf3), rados_read(ioctx, "foo", buf3, sizeof(buf3), 0));
- ASSERT_EQ(0, memcmp(buf3, buf, sizeof(buf)));
-
- ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_remove(ioctx, my_snaps.back()));
- my_snaps.pop_back();
- ASSERT_EQ(0, rados_ioctx_selfmanaged_snap_remove(ioctx, my_snaps.back()));
- my_snaps.pop_back();
- rados_ioctx_destroy(ioctx);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosSnapshots, SelfManagedSnapTestPP) {
- std::vector<uint64_t> my_snaps;
- Rados cluster;
- IoCtx ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- ASSERT_EQ(0, cluster.ioctx_create(pool_name.c_str(), ioctx));
-
- my_snaps.push_back(-2);
- ASSERT_EQ(0, ioctx.selfmanaged_snap_create(&my_snaps.back()));
- ::std::reverse(my_snaps.begin(), my_snaps.end());
- ASSERT_EQ(0, ioctx.selfmanaged_snap_set_write_ctx(my_snaps[0], my_snaps));
- ::std::reverse(my_snaps.begin(), my_snaps.end());
- char buf[128];
- memset(buf, 0xcc, sizeof(buf));
- bufferlist bl1;
- bl1.append(buf, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl1, sizeof(buf), 0));
-
- my_snaps.push_back(-2);
- ASSERT_EQ(0, ioctx.selfmanaged_snap_create(&my_snaps.back()));
- ::std::reverse(my_snaps.begin(), my_snaps.end());
- ASSERT_EQ(0, ioctx.selfmanaged_snap_set_write_ctx(my_snaps[0], my_snaps));
- ::std::reverse(my_snaps.begin(), my_snaps.end());
- char buf2[sizeof(buf)];
- memset(buf2, 0xdd, sizeof(buf2));
- bufferlist bl2;
- bl2.append(buf2, sizeof(buf2));
- ASSERT_EQ((int)sizeof(buf2), ioctx.write("foo", bl2, sizeof(buf2), 0));
-
- ioctx.snap_set_read(my_snaps[1]);
- bufferlist bl3;
- ASSERT_EQ((int)sizeof(buf), ioctx.read("foo", bl3, sizeof(buf), 0));
- ASSERT_EQ(0, memcmp(bl3.c_str(), buf, sizeof(buf)));
-
- ASSERT_EQ(0, ioctx.selfmanaged_snap_remove(my_snaps.back()));
- my_snaps.pop_back();
- ASSERT_EQ(0, ioctx.selfmanaged_snap_remove(my_snaps.back()));
- my_snaps.pop_back();
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
-
-TEST(LibRadosSnapshots, SelfManagedSnapRollbackPP) {
- std::vector<uint64_t> my_snaps;
- Rados cluster;
- IoCtx ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- ASSERT_EQ(0, cluster.ioctx_create(pool_name.c_str(), ioctx));
-
- my_snaps.push_back(-2);
- ASSERT_EQ(0, ioctx.selfmanaged_snap_create(&my_snaps.back()));
- ::std::reverse(my_snaps.begin(), my_snaps.end());
- ASSERT_EQ(0, ioctx.selfmanaged_snap_set_write_ctx(my_snaps[0], my_snaps));
- ::std::reverse(my_snaps.begin(), my_snaps.end());
- char buf[128];
- memset(buf, 0xcc, sizeof(buf));
- bufferlist bl1;
- bl1.append(buf, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl1, sizeof(buf), 0));
-
- my_snaps.push_back(-2);
- ASSERT_EQ(0, ioctx.selfmanaged_snap_create(&my_snaps.back()));
- ::std::reverse(my_snaps.begin(), my_snaps.end());
- ASSERT_EQ(0, ioctx.selfmanaged_snap_set_write_ctx(my_snaps[0], my_snaps));
- ::std::reverse(my_snaps.begin(), my_snaps.end());
- char buf2[sizeof(buf)];
- memset(buf2, 0xdd, sizeof(buf2));
- bufferlist bl2;
- bl2.append(buf2, sizeof(buf2));
- ASSERT_EQ((int)sizeof(buf2), ioctx.write("foo", bl2, sizeof(buf2), 0));
-
- string foo_str("foo");
- ioctx.selfmanaged_snap_rollback(foo_str, my_snaps[1]);
- bufferlist bl3;
- ASSERT_EQ((int)sizeof(buf), ioctx.read("foo", bl3, sizeof(buf), 0));
- ASSERT_EQ(0, memcmp(bl3.c_str(), buf, sizeof(buf)));
-
- ASSERT_EQ(0, ioctx.selfmanaged_snap_remove(my_snaps.back()));
- my_snaps.pop_back();
- ASSERT_EQ(0, ioctx.selfmanaged_snap_remove(my_snaps.back()));
- my_snaps.pop_back();
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
+++ /dev/null
-#include "include/rados/librados.h"
-#include "include/rados/librados.hpp"
-#include "test/rados-api/test.h"
-
-#include <algorithm>
-#include <errno.h>
-#include "gtest/gtest.h"
-
-using namespace librados;
-
-TEST(LibRadosStat, Stat) {
- char buf[128];
- rados_t cluster;
- rados_ioctx_t ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
- memset(buf, 0xcc, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
- uint64_t size;
- time_t mtime;
- ASSERT_EQ(0, rados_stat(ioctx, "foo", &size, &mtime));
- ASSERT_EQ(sizeof(buf), size);
- ASSERT_EQ(-ENOENT, rados_stat(ioctx, "nonexistent", &size, &mtime));
- rados_ioctx_destroy(ioctx);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosStat, StatPP) {
- char buf[128];
- Rados cluster;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- IoCtx ioctx;
- cluster.ioctx_create(pool_name.c_str(), ioctx);
- memset(buf, 0xcc, sizeof(buf));
- bufferlist bl;
- bl.append(buf, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl, sizeof(buf), 0));
- uint64_t size;
- time_t mtime;
- ASSERT_EQ(0, ioctx.stat("foo", &size, &mtime));
- ASSERT_EQ(sizeof(buf), size);
- ASSERT_EQ(-ENOENT, ioctx.stat("nonexistent", &size, &mtime));
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
-
-TEST(LibRadosStat, ClusterStat) {
- rados_t cluster;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- struct rados_cluster_stat_t result;
- ASSERT_EQ(0, rados_cluster_stat(cluster, &result));
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosStat, ClusterStatPP) {
- Rados cluster;
- cluster_stat_t cstat;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- ASSERT_EQ(0, cluster.cluster_stat(cstat));
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
-
-TEST(LibRadosStat, PoolStat) {
- char buf[128];
- rados_t cluster;
- rados_ioctx_t ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
- char actual_pool_name[80];
- unsigned l = rados_ioctx_get_pool_name(ioctx, actual_pool_name, sizeof(actual_pool_name));
- ASSERT_EQ(strlen(actual_pool_name), l);
- ASSERT_EQ(0, strcmp(actual_pool_name, pool_name.c_str()));
- memset(buf, 0xff, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
- struct rados_pool_stat_t stats;
- memset(&stats, 0, sizeof(stats));
- ASSERT_EQ(0, rados_ioctx_pool_stat(ioctx, &stats));
- rados_ioctx_destroy(ioctx);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
-}
-
-TEST(LibRadosStat, PoolStatPP) {
- Rados cluster;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- IoCtx ioctx;
- cluster.ioctx_create(pool_name.c_str(), ioctx);
- std::string n = ioctx.get_pool_name();
- ASSERT_EQ(n, pool_name);
- char buf[128];
- memset(buf, 0xff, sizeof(buf));
- bufferlist bl1;
- bl1.append(buf, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl1, sizeof(buf), 0));
- std::list<std::string> v;
- std::map<std::string,stats_map> stats;
- ASSERT_EQ(0, cluster.get_pool_stats(v, stats));
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
+++ /dev/null
-#include "include/rados/librados.h"
-#include "include/rados/librados.hpp"
-#include "test/rados-api/test.h"
-
-#include <sstream>
-#include <stdlib.h>
-#include <string>
-#include <time.h>
-#include <unistd.h>
-
-using namespace librados;
-
-std::string get_temp_pool_name()
-{
- char hostname[80];
- char out[80];
- memset(hostname, 0, sizeof(hostname));
- memset(out, 0, sizeof(out));
- gethostname(hostname, sizeof(hostname)-1);
- static int num = 1;
- sprintf(out, "%s-%d-%d", hostname, getpid(), num);
- num++;
- std::string prefix("test-rados-api-");
- prefix += out;
- return prefix;
-}
-
-std::string create_one_pool(const std::string &pool_name, rados_t *cluster)
-{
- int ret;
- ret = rados_create(cluster, NULL);
- if (ret) {
- std::ostringstream oss;
- oss << "rados_create failed with error " << ret;
- return oss.str();
- }
- ret = rados_conf_read_file(*cluster, NULL);
- if (ret) {
- rados_shutdown(*cluster);
- std::ostringstream oss;
- oss << "rados_conf_read_file failed with error " << ret;
- return oss.str();
- }
- rados_conf_parse_env(*cluster, NULL);
- ret = rados_connect(*cluster);
- if (ret) {
- rados_shutdown(*cluster);
- std::ostringstream oss;
- oss << "rados_connect failed with error " << ret;
- return oss.str();
- }
- ret = rados_pool_create(*cluster, pool_name.c_str());
- if (ret) {
- rados_shutdown(*cluster);
- std::ostringstream oss;
- oss << "rados_pool_create(" << pool_name << ") failed with error " << ret;
- return oss.str();
- }
- return "";
-}
-
-std::string create_one_pool_pp(const std::string &pool_name, Rados &cluster)
-{
- char *id = getenv("CEPH_CLIENT_ID");
- if (id) std::cerr << "Client id is: " << id << std::endl;
-
- int ret;
- ret = cluster.init(id);
- if (ret) {
- std::ostringstream oss;
- oss << "cluster.init failed with error " << ret;
- return oss.str();
- }
- ret = cluster.conf_read_file(NULL);
- if (ret) {
- cluster.shutdown();
- std::ostringstream oss;
- oss << "cluster.conf_read_file failed with error " << ret;
- return oss.str();
- }
- cluster.conf_parse_env(NULL);
- ret = cluster.connect();
- if (ret) {
- cluster.shutdown();
- std::ostringstream oss;
- oss << "cluster.connect failed with error " << ret;
- return oss.str();
- }
- ret = cluster.pool_create(pool_name.c_str());
- if (ret) {
- cluster.shutdown();
- std::ostringstream oss;
- oss << "cluster.pool_create(" << pool_name << ") failed with error " << ret;
- return oss.str();
- }
- return "";
-}
-
-std::string connect_cluster_pp(Rados &cluster)
-{
- char *id = getenv("CEPH_CLIENT_ID");
- if (id) std::cerr << "Client id is: " << id << std::endl;
-
- int ret;
- ret = cluster.init(id);
- if (ret) {
- std::ostringstream oss;
- oss << "cluster.init failed with error " << ret;
- return oss.str();
- }
- ret = cluster.conf_read_file(NULL);
- if (ret) {
- cluster.shutdown();
- std::ostringstream oss;
- oss << "cluster.conf_read_file failed with error " << ret;
- return oss.str();
- }
- cluster.conf_parse_env(NULL);
- ret = cluster.connect();
- if (ret) {
- cluster.shutdown();
- std::ostringstream oss;
- oss << "cluster.connect failed with error " << ret;
- return oss.str();
- }
- return "";
-}
-
-int destroy_one_pool(const std::string &pool_name, rados_t *cluster)
-{
- int ret = rados_pool_delete(*cluster, pool_name.c_str());
- if (ret) {
- rados_shutdown(*cluster);
- return ret;
- }
- rados_shutdown(*cluster);
- return 0;
-}
-
-int destroy_one_pool_pp(const std::string &pool_name, Rados &cluster)
-{
- int ret = cluster.pool_delete(pool_name.c_str());
- if (ret) {
- cluster.shutdown();
- return ret;
- }
- cluster.shutdown();
- return 0;
-}
+++ /dev/null
-// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
-// vim: ts=8 sw=2 smarttab
-/*
- * Ceph - scalable distributed file system
- *
- * Copyright (C) 2011 New Dream Network
- *
- * This is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License version 2.1, as published by the Free Software
- * Foundation. See file COPYING.
- *
- */
-
-#ifndef CEPH_TEST_RADOS_API_TEST_H
-#define CEPH_TEST_RADOS_API_TEST_H
-
-#include "include/rados/librados.h"
-#include "include/rados/librados.hpp"
-
-#include <string>
-#include <unistd.h>
-
-std::string get_temp_pool_name();
-
-std::string create_one_pool(const std::string &pool_name, rados_t *cluster);
-std::string create_one_pool_pp(const std::string &pool_name,
- librados::Rados &cluster);
-std::string connect_cluster_pp(librados::Rados &cluster);
-int destroy_one_pool(const std::string &pool_name, rados_t *cluster);
-int destroy_one_pool_pp(const std::string &pool_name, librados::Rados &cluster);
-
-class TestAlarm
-{
-public:
- TestAlarm() {
- alarm(360);
- }
- ~TestAlarm() {
- alarm(0);
- }
-};
-
-#endif
+++ /dev/null
-#include "include/rados/librados.h"
-#include "include/rados/librados.hpp"
-#include "test/rados-api/test.h"
-
-#include <errno.h>
-#include <semaphore.h>
-#include "gtest/gtest.h"
-
-using namespace librados;
-
-static sem_t sem;
-
-static void watch_notify_test_cb(uint8_t opcode, uint64_t ver, void *arg)
-{
- sem_post(&sem);
-}
-
-class WatchNotifyTestCtx : public WatchCtx
-{
-public:
- void notify(uint8_t opcode, uint64_t ver, bufferlist& bl)
- {
- sem_post(&sem);
- }
-};
-
-TEST(LibRadosWatchNotify, WatchNotifyTest) {
- ASSERT_EQ(0, sem_init(&sem, 0, 0));
- char buf[128];
- rados_t cluster;
- rados_ioctx_t ioctx;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool(pool_name, &cluster));
- rados_ioctx_create(cluster, pool_name.c_str(), &ioctx);
- memset(buf, 0xcc, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), rados_write(ioctx, "foo", buf, sizeof(buf), 0));
- uint64_t handle;
- ASSERT_EQ(0,
- rados_watch(ioctx, "foo", 0, &handle, watch_notify_test_cb, NULL));
- ASSERT_EQ(0, rados_notify(ioctx, "foo", 0, NULL, 0));
- TestAlarm alarm;
- sem_wait(&sem);
- rados_unwatch(ioctx, "foo", handle);
- rados_ioctx_destroy(ioctx);
- ASSERT_EQ(0, destroy_one_pool(pool_name, &cluster));
- sem_destroy(&sem);
-}
-
-TEST(LibRadosWatchNotify, WatchNotifyTestPP) {
- ASSERT_EQ(0, sem_init(&sem, 0, 0));
- Rados cluster;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- IoCtx ioctx;
- cluster.ioctx_create(pool_name.c_str(), ioctx);
- char buf[128];
- memset(buf, 0xcc, sizeof(buf));
- bufferlist bl1;
- bl1.append(buf, sizeof(buf));
- ASSERT_EQ((int)sizeof(buf), ioctx.write("foo", bl1, sizeof(buf), 0));
- uint64_t handle;
- WatchNotifyTestCtx ctx;
- ASSERT_EQ(0, ioctx.watch("foo", 0, &handle, &ctx));
- bufferlist bl2;
- ASSERT_EQ(0, ioctx.notify("foo", 0, bl2));
- TestAlarm alarm;
- sem_wait(&sem);
- ioctx.unwatch("foo", handle);
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
- sem_destroy(&sem);
-}
-
-TEST(LibRadosWatchNotify, WatchNotifyTimeoutTestPP) {
- ASSERT_EQ(0, sem_init(&sem, 0, 0));
- Rados cluster;
- std::string pool_name = get_temp_pool_name();
- ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
- IoCtx ioctx;
- cluster.ioctx_create(pool_name.c_str(), ioctx);
- ioctx.set_notify_timeout(1);
- uint64_t handle;
- WatchNotifyTestCtx ctx;
- ASSERT_EQ(0, ioctx.watch("foo", 0, &handle, &ctx));
- ioctx.close();
- ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
- sem_destroy(&sem);
-}
#include "include/utime.h"
#include "common/Thread.h"
#include "common/Clock.h"
-#include "test/rados-api/test.h"
+#include "test/librados/test.h"
#include "gtest/gtest.h"
#include <semaphore.h>
projects / ceph.git / commitdiff