From: Sage Weil Date: Sun, 4 Nov 2012 11:57:04 +0000 (-0800) Subject: librados: test/rados-api/* -> test/librados/* X-Git-Tag: v0.55~130^2~15^2~1 X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=5893dd52a9a203a7a06216a71bc90cad3151e684;p=ceph.git librados: test/rados-api/* -> test/librados/* Signed-off-by: Sage Weil --- diff --git a/src/Makefile.am b/src/Makefile.am index 81fd1aa262f..1ddc7368924 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -244,7 +244,7 @@ kvstorebench_SOURCES = test/kv_store_bench.cc key_value_store/kv_flat_btree_asyn 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 @@ -807,7 +807,7 @@ unittest_texttable_LDADD = librados.la ${UNITTEST_LDADD} 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 @@ -818,7 +818,7 @@ test_librbd_fsx_CFLAGS = ${AM_CFLAGS} -Wno-format 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 \ @@ -828,12 +828,12 @@ test_cls_rbd_CXXFLAGS = ${AM_CXXFLAGS} ${UNITTEST_CXXFLAGS} 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} @@ -842,62 +842,62 @@ bin_DEBUGPROGRAMS += test_cls_lock 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} @@ -947,7 +947,7 @@ test_filejournal_LDADD = ${UNITTEST_STATIC_LDADD} $(LIBOS_LDA) $(LIBGLOBAL_LDA) 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} @@ -1845,7 +1845,7 @@ noinst_HEADERS = \ 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 \ diff --git a/src/test/cls_lock/test_cls_lock.cc b/src/test/cls_lock/test_cls_lock.cc index 316bc3f596c..39d3cebde10 100644 --- a/src/test/cls_lock/test_cls_lock.cc +++ b/src/test/cls_lock/test_cls_lock.cc @@ -19,7 +19,7 @@ #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; diff --git a/src/test/cls_rbd/test_cls_rbd.cc b/src/test/cls_rbd/test_cls_rbd.cc index dffa00b7543..6308980f55f 100644 --- a/src/test/cls_rbd/test_cls_rbd.cc +++ b/src/test/cls_rbd/test_cls_rbd.cc @@ -10,7 +10,7 @@ #include "cls/rbd/cls_rbd_client.h" #include "gtest/gtest.h" -#include "test/rados-api/test.h" +#include "test/librados/test.h" #include #include diff --git a/src/test/cls_refcount/test_cls_refcount.cc b/src/test/cls_refcount/test_cls_refcount.cc index 9792e9507b9..79d9c942061 100644 --- a/src/test/cls_refcount/test_cls_refcount.cc +++ b/src/test/cls_refcount/test_cls_refcount.cc @@ -5,7 +5,7 @@ #include "cls/refcount/cls_refcount_client.h" #include "gtest/gtest.h" -#include "test/rados-api/test.h" +#include "test/librados/test.h" #include #include diff --git a/src/test/cls_rgw/test_cls_rgw.cc b/src/test/cls_rgw/test_cls_rgw.cc index 6ec20aeb674..f38a6b5a475 100644 --- a/src/test/cls_rgw/test_cls_rgw.cc +++ b/src/test/cls_rgw/test_cls_rgw.cc @@ -5,7 +5,7 @@ #include "cls/rgw/cls_rgw_client.h" #include "gtest/gtest.h" -#include "test/rados-api/test.h" +#include "test/librados/test.h" #include #include diff --git a/src/test/librados/aio.cc b/src/test/librados/aio.cc new file mode 100644 index 00000000000..4983fee7bc7 --- /dev/null +++ b/src/test/librados/aio.cc @@ -0,0 +1,914 @@ +#include "common/errno.h" +#include "include/rados/librados.h" +#include "test/librados/test.h" +#include "include/types.h" + +#include "gtest/gtest.h" +#include +#include +#include +#include +#include +#include + +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 to_set; + { + boost::scoped_ptr 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 my_completion(cluster.aio_create_completion(0, 0, 0)); + ObjectReadOperation op; + map > assertions; + bufferlist val; + val.append(string("bar")); + assertions["foo"] = pair(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 my_completion(cluster.aio_create_completion(0, 0, 0)); + ObjectReadOperation op; + + set set_got; + map map_got; + + set to_get; + map got3; + + map 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 my_completion(cluster.aio_create_completion(0, 0, 0)); + ObjectWriteOperation op; + set 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 my_completion(cluster.aio_create_completion(0, 0, 0)); + ObjectReadOperation op; + + set 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 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 my_completion(cluster.aio_create_completion(0, 0, 0)); + ObjectReadOperation op; + + set 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"); +} diff --git a/src/test/librados/cls.cc b/src/test/librados/cls.cc new file mode 100644 index 00000000000..1f61664b487 --- /dev/null +++ b/src/test/librados/cls.cc @@ -0,0 +1,37 @@ +#include "include/rados/librados.h" +#include "include/rados/librados.hpp" +#include "test/librados/test.h" + +#include "gtest/gtest.h" +#include +#include +#include +#include + +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)); +} diff --git a/src/test/librados/io.cc b/src/test/librados/io.cc new file mode 100644 index 00000000000..e09f1764361 --- /dev/null +++ b/src/test/librados/io.cc @@ -0,0 +1,457 @@ +#include "include/rados/librados.h" +#include "include/rados/librados.hpp" +#include "test/librados/test.h" + +#include +#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 attrset; + ASSERT_EQ(0, ioctx.getxattrs("foo", attrset)); + for (std::map::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)); +} diff --git a/src/test/librados/list.cc b/src/test/librados/list.cc new file mode 100644 index 00000000000..a1bea88260b --- /dev/null +++ b/src/test/librados/list.cc @@ -0,0 +1,49 @@ +#include "include/rados/librados.h" +#include "include/rados/librados.hpp" +#include "test/librados/test.h" + +#include "gtest/gtest.h" +#include +#include + +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)); +} diff --git a/src/test/librados/misc.cc b/src/test/librados/misc.cc new file mode 100644 index 00000000000..30b0c3d6d13 --- /dev/null +++ b/src/test/librados/misc.cc @@ -0,0 +1,364 @@ +#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 +#include +#include +#include + +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 m; + ::decode(header, p); + ::decode(m, p); + map::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)); +} diff --git a/src/test/librados/pool.cc b/src/test/librados/pool.cc new file mode 100644 index 00000000000..0dffea1b78c --- /dev/null +++ b/src/test/librados/pool.cc @@ -0,0 +1,127 @@ +#include "include/rados/librados.h" +#include "test/librados/test.h" + +#include "gtest/gtest.h" +#include +#include + +#define POOL_LIST_BUF_SZ 32768 + +TEST(LibRadosPools, PoolList) { + std::vector 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)); +} diff --git a/src/test/librados/snapshots.cc b/src/test/librados/snapshots.cc new file mode 100644 index 00000000000..439fe3fd6a8 --- /dev/null +++ b/src/test/librados/snapshots.cc @@ -0,0 +1,351 @@ +#include "include/rados/librados.h" +#include "test/librados/test.h" + +#include +#include +#include "gtest/gtest.h" +#include + +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 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 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 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 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 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)); +} diff --git a/src/test/librados/stat.cc b/src/test/librados/stat.cc new file mode 100644 index 00000000000..3811a3795fb --- /dev/null +++ b/src/test/librados/stat.cc @@ -0,0 +1,105 @@ +#include "include/rados/librados.h" +#include "include/rados/librados.hpp" +#include "test/librados/test.h" + +#include +#include +#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 v; + std::map stats; + ASSERT_EQ(0, cluster.get_pool_stats(v, stats)); + ioctx.close(); + ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster)); +} diff --git a/src/test/librados/test.cc b/src/test/librados/test.cc new file mode 100644 index 00000000000..a1aa24c736c --- /dev/null +++ b/src/test/librados/test.cc @@ -0,0 +1,149 @@ +#include "include/rados/librados.h" +#include "include/rados/librados.hpp" +#include "test/librados/test.h" + +#include +#include +#include +#include +#include + +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; +} diff --git a/src/test/librados/test.h b/src/test/librados/test.h new file mode 100644 index 00000000000..df27ba0a687 --- /dev/null +++ b/src/test/librados/test.h @@ -0,0 +1,44 @@ +// -*- 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 +#include + +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 diff --git a/src/test/librados/watch_notify.cc b/src/test/librados/watch_notify.cc new file mode 100644 index 00000000000..b2de96d1332 --- /dev/null +++ b/src/test/librados/watch_notify.cc @@ -0,0 +1,88 @@ +#include "include/rados/librados.h" +#include "include/rados/librados.hpp" +#include "test/librados/test.h" + +#include +#include +#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); +} diff --git a/src/test/librbd/test_librbd.cc b/src/test/librbd/test_librbd.cc index 96dcfc2c9bd..80d31a7f9c4 100644 --- a/src/test/librbd/test_librbd.cc +++ b/src/test/librbd/test_librbd.cc @@ -31,7 +31,7 @@ #include #include -#include "rados-api/test.h" +#include "test/librados/test.h" #include "common/errno.h" #include "include/stringify.h" diff --git a/src/test/multi_stress_watch.cc b/src/test/multi_stress_watch.cc index bb3349b8e01..eb21bdaa450 100644 --- a/src/test/multi_stress_watch.cc +++ b/src/test/multi_stress_watch.cc @@ -1,7 +1,7 @@ // -*- 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 #include diff --git a/src/test/osd/RadosModel.h b/src/test/osd/RadosModel.h index 425c7a61b7a..21112d1067f 100644 --- a/src/test/osd/RadosModel.h +++ b/src/test/osd/RadosModel.h @@ -16,7 +16,7 @@ #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 diff --git a/src/test/rados-api/aio.cc b/src/test/rados-api/aio.cc deleted file mode 100644 index 90ef6a63039..00000000000 --- a/src/test/rados-api/aio.cc +++ /dev/null @@ -1,914 +0,0 @@ -#include "common/errno.h" -#include "include/rados/librados.h" -#include "test/rados-api/test.h" -#include "include/types.h" - -#include "gtest/gtest.h" -#include -#include -#include -#include -#include -#include - -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 to_set; - { - boost::scoped_ptr 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 my_completion(cluster.aio_create_completion(0, 0, 0)); - ObjectReadOperation op; - map > assertions; - bufferlist val; - val.append(string("bar")); - assertions["foo"] = pair(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 my_completion(cluster.aio_create_completion(0, 0, 0)); - ObjectReadOperation op; - - set set_got; - map map_got; - - set to_get; - map got3; - - map 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 my_completion(cluster.aio_create_completion(0, 0, 0)); - ObjectWriteOperation op; - set 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 my_completion(cluster.aio_create_completion(0, 0, 0)); - ObjectReadOperation op; - - set 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 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 my_completion(cluster.aio_create_completion(0, 0, 0)); - ObjectReadOperation op; - - set 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"); -} diff --git a/src/test/rados-api/cls.cc b/src/test/rados-api/cls.cc deleted file mode 100644 index e20ee11e406..00000000000 --- a/src/test/rados-api/cls.cc +++ /dev/null @@ -1,37 +0,0 @@ -#include "include/rados/librados.h" -#include "include/rados/librados.hpp" -#include "test/rados-api/test.h" - -#include "gtest/gtest.h" -#include -#include -#include -#include - -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)); -} diff --git a/src/test/rados-api/io.cc b/src/test/rados-api/io.cc deleted file mode 100644 index 1b938102906..00000000000 --- a/src/test/rados-api/io.cc +++ /dev/null @@ -1,457 +0,0 @@ -#include "include/rados/librados.h" -#include "include/rados/librados.hpp" -#include "test/rados-api/test.h" - -#include -#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 attrset; - ASSERT_EQ(0, ioctx.getxattrs("foo", attrset)); - for (std::map::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)); -} diff --git a/src/test/rados-api/list.cc b/src/test/rados-api/list.cc deleted file mode 100644 index d94aebe2afc..00000000000 --- a/src/test/rados-api/list.cc +++ /dev/null @@ -1,49 +0,0 @@ -#include "include/rados/librados.h" -#include "include/rados/librados.hpp" -#include "test/rados-api/test.h" - -#include "gtest/gtest.h" -#include -#include - -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)); -} diff --git a/src/test/rados-api/misc.cc b/src/test/rados-api/misc.cc deleted file mode 100644 index 5f0545adb60..00000000000 --- a/src/test/rados-api/misc.cc +++ /dev/null @@ -1,364 +0,0 @@ -#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 -#include -#include -#include - -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 m; - ::decode(header, p); - ::decode(m, p); - map::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)); -} diff --git a/src/test/rados-api/pool.cc b/src/test/rados-api/pool.cc deleted file mode 100644 index 652c1deb788..00000000000 --- a/src/test/rados-api/pool.cc +++ /dev/null @@ -1,127 +0,0 @@ -#include "include/rados/librados.h" -#include "test/rados-api/test.h" - -#include "gtest/gtest.h" -#include -#include - -#define POOL_LIST_BUF_SZ 32768 - -TEST(LibRadosPools, PoolList) { - std::vector 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)); -} diff --git a/src/test/rados-api/snapshots.cc b/src/test/rados-api/snapshots.cc deleted file mode 100644 index 80d1aa9f514..00000000000 --- a/src/test/rados-api/snapshots.cc +++ /dev/null @@ -1,351 +0,0 @@ -#include "include/rados/librados.h" -#include "test/rados-api/test.h" - -#include -#include -#include "gtest/gtest.h" -#include - -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 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 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 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 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 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)); -} diff --git a/src/test/rados-api/stat.cc b/src/test/rados-api/stat.cc deleted file mode 100644 index 63cb4446081..00000000000 --- a/src/test/rados-api/stat.cc +++ /dev/null @@ -1,105 +0,0 @@ -#include "include/rados/librados.h" -#include "include/rados/librados.hpp" -#include "test/rados-api/test.h" - -#include -#include -#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 v; - std::map stats; - ASSERT_EQ(0, cluster.get_pool_stats(v, stats)); - ioctx.close(); - ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster)); -} diff --git a/src/test/rados-api/test.cc b/src/test/rados-api/test.cc deleted file mode 100644 index 9ba9641c2b8..00000000000 --- a/src/test/rados-api/test.cc +++ /dev/null @@ -1,149 +0,0 @@ -#include "include/rados/librados.h" -#include "include/rados/librados.hpp" -#include "test/rados-api/test.h" - -#include -#include -#include -#include -#include - -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; -} diff --git a/src/test/rados-api/test.h b/src/test/rados-api/test.h deleted file mode 100644 index df27ba0a687..00000000000 --- a/src/test/rados-api/test.h +++ /dev/null @@ -1,44 +0,0 @@ -// -*- 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 -#include - -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 diff --git a/src/test/rados-api/watch_notify.cc b/src/test/rados-api/watch_notify.cc deleted file mode 100644 index 88dcabfa3bc..00000000000 --- a/src/test/rados-api/watch_notify.cc +++ /dev/null @@ -1,88 +0,0 @@ -#include "include/rados/librados.h" -#include "include/rados/librados.hpp" -#include "test/rados-api/test.h" - -#include -#include -#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); -} diff --git a/src/test/test_stress_watch.cc b/src/test/test_stress_watch.cc index 44fcdf99105..2192815ab2e 100644 --- a/src/test/test_stress_watch.cc +++ b/src/test/test_stress_watch.cc @@ -4,7 +4,7 @@ #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