}
void RadosTestFixture::TearDownTestCase() {
- ASSERT_EQ(0, destroy_one_pool_pp(_pool_name, _rados));
-
_thread_pool->stop();
delete _thread_pool;
+
+ ASSERT_EQ(0, destroy_one_pool_pp(_pool_name, _rados));
}
std::string RadosTestFixture::get_temp_oid() {
LibradosTestStub.cc
TestClassHandler.cc
TestIoCtxImpl.cc
+ TestMemCluster.cc
TestMemIoCtxImpl.cc
TestMemRadosClient.cc
TestRadosClient.cc
TestWatchNotify.cc)
add_library(rados_test_stub STATIC ${librados_test_stub_srcs})
-
+
#include "common/config.h"
#include "common/debug.h"
#include "common/snap_types.h"
-#include "global/global_context.h"
#include "librados/AioCompletionImpl.h"
#include "test/librados_test_stub/TestClassHandler.h"
#include "test/librados_test_stub/TestIoCtxImpl.h"
#include "test/librados_test_stub/TestRadosClient.h"
+#include "test/librados_test_stub/TestMemCluster.h"
#include "test/librados_test_stub/TestMemRadosClient.h"
#include "objclass/objclass.h"
#include "osd/osd_types.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rados
+namespace librados {
+
+MockTestMemIoCtxImpl &get_mock_io_ctx(IoCtx &ioctx) {
+ MockTestMemIoCtxImpl **mock =
+ reinterpret_cast<MockTestMemIoCtxImpl **>(&ioctx);
+ return **mock;
+}
+
+} // namespace librados
+
+namespace librados_test_stub {
+
+TestClusterRef &cluster() {
+ static TestClusterRef s_cluster;
+ return s_cluster;
+}
+
+void set_cluster(TestClusterRef cluster_ref) {
+ cluster() = cluster_ref;
+}
+
+TestClusterRef get_cluster() {
+ auto &cluster_ref = cluster();
+ if (cluster_ref.get() == nullptr) {
+ cluster_ref.reset(new librados::TestMemCluster());
+ }
+ return cluster_ref;
+}
+
+} // namespace librados_test_stub
+
namespace {
librados::TestClassHandler *get_class_handler() {
}
}
-} // anonymous namespace
-
-namespace librados {
+librados::TestRadosClient *create_rados_client() {
+ CephInitParameters iparams(CEPH_ENTITY_TYPE_CLIENT);
+ CephContext *cct = common_preinit(iparams, CODE_ENVIRONMENT_LIBRARY, 0);
+ cct->_conf->parse_env();
+ cct->_conf->apply_changes(nullptr);
-MockTestMemIoCtxImpl &get_mock_io_ctx(IoCtx &ioctx) {
- MockTestMemIoCtxImpl **mock =
- reinterpret_cast<MockTestMemIoCtxImpl **>(&ioctx);
- return **mock;
+ auto rados_client =
+ librados_test_stub::get_cluster()->create_rados_client(cct);
+ cct->put();
+ return rados_client;
}
-}
-
-namespace librados_test_stub {
-
-TestRadosClientPtr *rados_client() {
- // force proper destruction order by delaying construction
- static TestRadosClientPtr s_rados_client;
- return &s_rados_client;
-}
-
-void set_rados_client(
- const boost::shared_ptr<librados::TestRadosClient> &new_client) {
- assert(new_client.get() != nullptr);
- *rados_client() = new_client;
-}
-
-TestRadosClientPtr get_rados_client() {
- // TODO: use factory to allow tests to swap out impl
- TestRadosClientPtr *client = rados_client();
- if (client->get() == nullptr) {
- CephInitParameters iparams(CEPH_ENTITY_TYPE_CLIENT);
- CephContext *cct = common_preinit(iparams, CODE_ENVIRONMENT_LIBRARY, 0);
- cct->_conf->parse_env();
- cct->_conf->apply_changes(NULL);
- client->reset(new librados::TestMemRadosClient(cct),
- &librados::TestRadosClient::Deallocate);
- if (g_ceph_context == NULL) {
- g_ceph_context = cct;
- }
- cct->put();
- }
- (*client)->get();
- return *client;
-}
-
-} // namespace librados_test_stub
+} // anonymous namespace
extern "C" int rados_aio_create_completion(void *cb_arg,
rados_callback_t cb_complete,
}
extern "C" int rados_create(rados_t *cluster, const char * const id) {
- *cluster = librados_test_stub::get_rados_client().get();
+ *cluster = create_rados_client();
return 0;
}
#include <boost/shared_ptr.hpp>
namespace librados {
+
class IoCtx;
-class TestRadosClient;
class MockTestMemIoCtxImpl;
+class TestCluster;
MockTestMemIoCtxImpl &get_mock_io_ctx(IoCtx &ioctx);
-}
-namespace librados_test_stub {
+} // namespace librados
-typedef boost::shared_ptr<librados::TestRadosClient> TestRadosClientPtr;
+namespace librados_test_stub {
-void set_rados_client(const TestRadosClientPtr &rados_client);
+typedef boost::shared_ptr<librados::TestCluster> TestClusterRef;
-TestRadosClientPtr get_rados_client();
+void set_cluster(TestClusterRef cluster);
+TestClusterRef get_cluster();
} // namespace librados_test_stub
+
#endif // LIBRADOS_TEST_STUB_H
--- /dev/null
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab
+
+#ifndef LIBRADOS_MOCK_TEST_MEM_CLUSTER_H
+#define LIBRADOS_MOCK_TEST_MEM_CLUSTER_H
+
+#include "test/librados_test_stub/TestMemCluster.h"
+#include "test/librados_test_stub/MockTestMemRadosClient.h"
+#include "gmock/gmock.h"
+
+struct CephContext;
+
+namespace librados {
+
+class TestRadosClient;
+
+class MockTestMemCluster : public TestCluster {
+public:
+ TestRadosClient *create_rados_client(CephContext *cct) override {
+ return new ::testing::NiceMock<librados::MockTestMemRadosClient>(
+ cct, &m_mem_cluster);
+ }
+
+private:
+ TestMemCluster m_mem_cluster;
+
+};
+
+} // namespace librados
+
+#endif // LIBRADOS_MOCK_TEST_MEM_CLUSTER_H
#define LIBRADOS_TEST_STUB_MOCK_TEST_MEM_IO_CTX_IMPL_H
#include "test/librados_test_stub/TestMemIoCtxImpl.h"
+#include "test/librados_test_stub/TestMemCluster.h"
#include "gmock/gmock.h"
namespace librados {
MockTestMemIoCtxImpl(MockTestMemRadosClient *mock_client,
TestMemRadosClient *client, int64_t pool_id,
const std::string& pool_name,
- TestMemRadosClient::Pool *pool)
+ TestMemCluster::Pool *pool)
: TestMemIoCtxImpl(client, pool_id, pool_name, pool),
m_mock_client(mock_client), m_client(client) {
default_to_parent();
namespace librados {
+class TestMemCluster;
+
class MockTestMemRadosClient : public TestMemRadosClient {
public:
- MockTestMemRadosClient(CephContext *cct) : TestMemRadosClient(cct) {
+ MockTestMemRadosClient(CephContext *cct, TestMemCluster *test_mem_cluster)
+ : TestMemRadosClient(cct, test_mem_cluster) {
default_to_dispatch();
}
TestIoCtxImpl *do_create_ioctx(int64_t pool_id,
const std::string &pool_name) {
return new ::testing::NiceMock<MockTestMemIoCtxImpl>(
- this, this, pool_id, pool_name, get_pool(pool_name));
+ this, this, pool_id, pool_name,
+ get_mem_cluster()->get_pool(pool_name));
}
MOCK_METHOD2(blacklist_add, int(const std::string& client_address,
--- /dev/null
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab
+
+#ifndef CEPH_TEST_CLUSTER_H
+#define CEPH_TEST_CLUSTER_H
+
+#include "test/librados_test_stub/TestWatchNotify.h"
+
+class CephContext;
+
+namespace librados {
+
+class TestRadosClient;
+class TestWatchNotify;
+
+class TestCluster {
+public:
+ virtual ~TestCluster() {
+ }
+
+ virtual TestRadosClient *create_rados_client(CephContext *cct) = 0;
+
+ TestWatchNotify *get_watch_notify() {
+ return &m_watch_notify;
+ }
+
+private:
+ TestWatchNotify m_watch_notify;
+
+};
+
+} // namespace librados
+
+#endif // CEPH_TEST_CLUSTER_H
m_pending_ops.inc();
c->get();
C_AioNotify *ctx = new C_AioNotify(this, c);
- m_client->get_watch_notify().aio_notify(oid, bl, timeout_ms, pbl, ctx);
+ m_client->get_watch_notify()->aio_notify(m_client, oid, bl, timeout_ms, pbl,
+ ctx);
}
int TestIoCtxImpl::aio_operate(const std::string& oid, TestObjectOperationImpl &ops,
m_pending_ops.inc();
c->get();
C_AioNotify *ctx = new C_AioNotify(this, c);
- m_client->get_watch_notify().aio_watch(o, get_instance_id(), handle,
- watch_ctx, ctx);
+ m_client->get_watch_notify()->aio_watch(m_client, o, get_instance_id(),
+ handle, watch_ctx, ctx);
return 0;
}
m_pending_ops.inc();
c->get();
C_AioNotify *ctx = new C_AioNotify(this, c);
- m_client->get_watch_notify().aio_unwatch(handle, ctx);
+ m_client->get_watch_notify()->aio_unwatch(m_client, handle, ctx);
return 0;
}
int TestIoCtxImpl::list_watchers(const std::string& o,
std::list<obj_watch_t> *out_watchers) {
- return m_client->get_watch_notify().list_watchers(o, out_watchers);
+ return m_client->get_watch_notify()->list_watchers(o, out_watchers);
}
int TestIoCtxImpl::notify(const std::string& o, bufferlist& bl,
uint64_t timeout_ms, bufferlist *pbl) {
- return m_client->get_watch_notify().notify(o, bl, timeout_ms, pbl);
+ return m_client->get_watch_notify()->notify(m_client, o, bl, timeout_ms, pbl);
}
void TestIoCtxImpl::notify_ack(const std::string& o, uint64_t notify_id,
uint64_t handle, bufferlist& bl) {
- m_client->get_watch_notify().notify_ack(o, notify_id, handle,
- m_client->get_instance_id(), bl);
+ m_client->get_watch_notify()->notify_ack(m_client, o, notify_id, handle,
+ m_client->get_instance_id(), bl);
}
int TestIoCtxImpl::operate(const std::string& oid, TestObjectOperationImpl &ops) {
}
int TestIoCtxImpl::unwatch(uint64_t handle) {
- return m_client->get_watch_notify().unwatch(handle);
+ return m_client->get_watch_notify()->unwatch(m_client, handle);
}
int TestIoCtxImpl::watch(const std::string& o, uint64_t *handle,
librados::WatchCtx *ctx, librados::WatchCtx2 *ctx2) {
- return m_client->get_watch_notify().watch(o, get_instance_id(), handle, ctx,
- ctx2);
+ return m_client->get_watch_notify()->watch(m_client, o, get_instance_id(),
+ handle, ctx, ctx2);
}
int TestIoCtxImpl::execute_operation(const std::string& oid,
--- /dev/null
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab
+
+#include "test/librados_test_stub/TestMemCluster.h"
+#include "test/librados_test_stub/TestMemRadosClient.h"
+
+namespace librados {
+
+TestMemCluster::File::File()
+ : snap_id(), exists(true), lock("TestMemCluster::File::lock") {
+}
+
+TestMemCluster::File::File(const File &rhs)
+ : data(rhs.data),
+ mtime(rhs.mtime),
+ snap_id(rhs.snap_id),
+ exists(rhs.exists),
+ lock("TestMemCluster::File::lock") {
+}
+
+TestMemCluster::Pool::Pool()
+ : file_lock("TestMemCluster::Pool::file_lock") {
+}
+
+TestMemCluster::TestMemCluster()
+ : m_lock("TestMemCluster::m_lock") {
+}
+
+TestMemCluster::~TestMemCluster() {
+ for (auto pool_pair : m_pools) {
+ pool_pair.second->put();
+ }
+}
+
+TestRadosClient *TestMemCluster::create_rados_client(CephContext *cct) {
+ return new TestMemRadosClient(cct, this);
+}
+
+int TestMemCluster::pool_create(const std::string &pool_name) {
+ Mutex::Locker locker(m_lock);
+ if (m_pools.find(pool_name) != m_pools.end()) {
+ return -EEXIST;
+ }
+ Pool *pool = new Pool();
+ pool->pool_id = ++m_pool_id;
+ m_pools[pool_name] = pool;
+ return 0;
+}
+
+int TestMemCluster::pool_delete(const std::string &pool_name) {
+ Mutex::Locker locker(m_lock);
+ Pools::iterator iter = m_pools.find(pool_name);
+ if (iter == m_pools.end()) {
+ return -ENOENT;
+ }
+ iter->second->put();
+ m_pools.erase(iter);
+ return 0;
+}
+
+int TestMemCluster::pool_get_base_tier(int64_t pool_id, int64_t* base_tier) {
+ // TODO
+ *base_tier = pool_id;
+ return 0;
+}
+
+int TestMemCluster::pool_list(std::list<std::pair<int64_t, std::string> >& v) {
+ Mutex::Locker locker(m_lock);
+ v.clear();
+ for (Pools::iterator iter = m_pools.begin(); iter != m_pools.end(); ++iter) {
+ v.push_back(std::make_pair(iter->second->pool_id, iter->first));
+ }
+ return 0;
+}
+
+int64_t TestMemCluster::pool_lookup(const std::string &pool_name) {
+ Mutex::Locker locker(m_lock);
+ Pools::iterator iter = m_pools.find(pool_name);
+ if (iter == m_pools.end()) {
+ return -ENOENT;
+ }
+ return iter->second->pool_id;
+}
+
+int TestMemCluster::pool_reverse_lookup(int64_t id, std::string *name) {
+ Mutex::Locker locker(m_lock);
+ for (Pools::iterator iter = m_pools.begin(); iter != m_pools.end(); ++iter) {
+ if (iter->second->pool_id == id) {
+ *name = iter->first;
+ return 0;
+ }
+ }
+ return -ENOENT;
+}
+
+TestMemCluster::Pool *TestMemCluster::get_pool(int64_t pool_id) {
+ Mutex::Locker locker(m_lock);
+ for (auto &pool_pair : m_pools) {
+ if (pool_pair.second->pool_id == pool_id) {
+ return pool_pair.second;
+ }
+ }
+ return nullptr;
+}
+
+TestMemCluster::Pool *TestMemCluster::get_pool(const std::string &pool_name) {
+ Mutex::Locker locker(m_lock);
+ Pools::iterator iter = m_pools.find(pool_name);
+ if (iter != m_pools.end()) {
+ return iter->second;
+ }
+ return nullptr;
+}
+
+void TestMemCluster::transaction_start(const std::string &oid) {
+ Mutex::Locker locker(m_lock);
+ while (m_transactions.count(oid)) {
+ m_transaction_cond.Wait(m_lock);
+ }
+ std::pair<std::set<std::string>::iterator, bool> result =
+ m_transactions.insert(oid);
+ assert(result.second);
+}
+
+void TestMemCluster::transaction_finish(const std::string &oid) {
+ Mutex::Locker locker(m_lock);
+ size_t count = m_transactions.erase(oid);
+ assert(count == 1);
+ m_transaction_cond.Signal();
+}
+
+} // namespace librados
+
--- /dev/null
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab
+
+#ifndef CEPH_TEST_MEM_CLUSTER_H
+#define CEPH_TEST_MEM_CLUSTER_H
+
+#include "test/librados_test_stub/TestCluster.h"
+#include "include/buffer.h"
+#include "include/interval_set.h"
+#include "include/int_types.h"
+#include "common/Cond.h"
+#include "common/Mutex.h"
+#include "common/RefCountedObj.h"
+#include "common/RWLock.h"
+#include <boost/shared_ptr.hpp>
+#include <list>
+#include <map>
+#include <string>
+
+namespace librados {
+
+class TestMemCluster : public TestCluster {
+public:
+ typedef std::map<std::string, bufferlist> OMap;
+ typedef std::map<std::string, OMap> FileOMaps;
+ typedef std::map<std::string, bufferlist> FileTMaps;
+ typedef std::map<std::string, bufferlist> XAttrs;
+ typedef std::map<std::string, XAttrs> FileXAttrs;
+
+ struct File {
+ File();
+ File(const File &rhs);
+
+ bufferlist data;
+ time_t mtime;
+
+ uint64_t snap_id;
+ std::vector<uint64_t> snaps;
+ interval_set<uint64_t> snap_overlap;
+
+ bool exists;
+ RWLock lock;
+ };
+ typedef boost::shared_ptr<File> SharedFile;
+
+ typedef std::list<SharedFile> FileSnapshots;
+ typedef std::map<std::string, FileSnapshots> Files;
+
+ typedef std::set<uint64_t> SnapSeqs;
+ struct Pool : public RefCountedObject {
+ Pool();
+
+ int64_t pool_id = 0;
+
+ SnapSeqs snap_seqs;
+ uint64_t snap_id = 1;
+
+ RWLock file_lock;
+ Files files;
+ FileOMaps file_omaps;
+ FileTMaps file_tmaps;
+ FileXAttrs file_xattrs;
+ };
+
+ TestMemCluster();
+ ~TestMemCluster() override;
+
+ TestRadosClient *create_rados_client(CephContext *cct) override;
+
+ int pool_create(const std::string &pool_name);
+ int pool_delete(const std::string &pool_name);
+ int pool_get_base_tier(int64_t pool_id, int64_t* base_tier);
+ int pool_list(std::list<std::pair<int64_t, std::string> >& v);
+ int64_t pool_lookup(const std::string &name);
+ int pool_reverse_lookup(int64_t id, std::string *name);
+
+ Pool *get_pool(int64_t pool_id);
+ Pool *get_pool(const std::string &pool_name);
+
+ void transaction_start(const std::string &oid);
+ void transaction_finish(const std::string &oid);
+
+private:
+
+ typedef std::map<std::string, Pool*> Pools;
+
+ mutable Mutex m_lock;
+
+ Pools m_pools;
+ int64_t m_pool_id = 0;
+
+ Cond m_transaction_cond;
+ std::set<std::string> m_transactions;
+
+};
+
+} // namespace librados
+
+#endif // CEPH_TEST_MEM_CLUSTER_H
#include "test/librados_test_stub/TestMemIoCtxImpl.h"
#include "test/librados_test_stub/TestMemRadosClient.h"
#include "common/Clock.h"
+#include "common/RWLock.h"
#include <boost/algorithm/string/predicate.hpp>
#include <boost/bind.hpp>
#include <errno.h>
TestMemIoCtxImpl::TestMemIoCtxImpl(TestMemRadosClient *client, int64_t pool_id,
const std::string& pool_name,
- TestMemRadosClient::Pool *pool)
+ TestMemCluster::Pool *pool)
: TestIoCtxImpl(client, pool_id, pool_name), m_client(client),
m_pool(pool) {
m_pool->get();
return -EROFS;
}
- TestMemRadosClient::SharedFile file;
+ TestMemCluster::SharedFile file;
{
RWLock::WLocker l(m_pool->file_lock);
file = get_file(oid, true, snapc);
int TestMemIoCtxImpl::assert_exists(const std::string &oid) {
RWLock::RLocker l(m_pool->file_lock);
- TestMemRadosClient::SharedFile file = get_file(oid, false,
- get_snap_context());
+ TestMemCluster::SharedFile file = get_file(oid, false, get_snap_context());
if (file == NULL) {
return -ENOENT;
}
out_snaps->clones.clear();
RWLock::RLocker l(m_pool->file_lock);
- TestMemRadosClient::Files::iterator it = m_pool->files.find(oid);
+ TestMemCluster::Files::iterator it = m_pool->files.find(oid);
if (it == m_pool->files.end()) {
return -ENOENT;
}
bool include_head = false;
- TestMemRadosClient::FileSnapshots &file_snaps = it->second;
- for (TestMemRadosClient::FileSnapshots::iterator s_it = file_snaps.begin();
+ TestMemCluster::FileSnapshots &file_snaps = it->second;
+ for (TestMemCluster::FileSnapshots::iterator s_it = file_snaps.begin();
s_it != file_snaps.end(); ++s_it) {
- TestMemRadosClient::File &file = *s_it->get();
+ TestMemCluster::File &file = *s_it->get();
if (file_snaps.size() > 1) {
out_snaps->seq = file.snap_id;
- TestMemRadosClient::FileSnapshots::iterator next_it(s_it);
+ TestMemCluster::FileSnapshots::iterator next_it(s_it);
++next_it;
if (next_it == file_snaps.end()) {
include_head = true;
}
// update the overlap with the next version's overlap metadata
- TestMemRadosClient::File &next_file = *next_it->get();
+ TestMemCluster::File &next_file = *next_it->get();
interval_set<uint64_t> overlap;
if (next_file.exists) {
overlap = next_file.snap_overlap;
include_head)
{
// Include the SNAP_HEAD
- TestMemRadosClient::File &file = *file_snaps.back();
+ TestMemCluster::File &file = *file_snaps.back();
if (file.exists) {
RWLock::RLocker l2(file.lock);
if (out_snaps->seq == 0 && !include_head) {
return -EINVAL;
}
- TestMemRadosClient::SharedFile file;
+ TestMemCluster::SharedFile file;
{
RWLock::RLocker l(m_pool->file_lock);
file = get_file(oid, false, get_snap_context());
out_vals->clear();
RWLock::RLocker l(file->lock);
- TestMemRadosClient::FileOMaps::iterator o_it = m_pool->file_omaps.find(oid);
+ TestMemCluster::FileOMaps::iterator o_it = m_pool->file_omaps.find(oid);
if (o_it == m_pool->file_omaps.end()) {
return 0;
}
- TestMemRadosClient::OMap &omap = o_it->second;
- TestMemRadosClient::OMap::iterator it = omap.begin();
+ TestMemCluster::OMap &omap = o_it->second;
+ TestMemCluster::OMap::iterator it = omap.begin();
if (!start_after.empty()) {
it = omap.upper_bound(start_after);
}
return -EROFS;
}
- TestMemRadosClient::SharedFile file;
+ TestMemCluster::SharedFile file;
{
RWLock::WLocker l(m_pool->file_lock);
file = get_file(oid, true, get_snap_context());
return -EROFS;
}
- TestMemRadosClient::SharedFile file;
+ TestMemCluster::SharedFile file;
{
RWLock::WLocker l(m_pool->file_lock);
file = get_file(oid, true, get_snap_context());
int TestMemIoCtxImpl::read(const std::string& oid, size_t len, uint64_t off,
bufferlist *bl) {
- TestMemRadosClient::SharedFile file;
+ TestMemCluster::SharedFile file;
{
RWLock::RLocker l(m_pool->file_lock);
file = get_file(oid, false, get_snap_context());
}
RWLock::WLocker l(m_pool->file_lock);
- TestMemRadosClient::SharedFile file = get_file(oid, false, snapc);
+ TestMemCluster::SharedFile file = get_file(oid, false, snapc);
if (file == NULL) {
return -ENOENT;
}
RWLock::WLocker l2(file->lock);
file->exists = false;
- TestMemRadosClient::Files::iterator it = m_pool->files.find(oid);
+ TestMemCluster::Files::iterator it = m_pool->files.find(oid);
assert(it != m_pool->files.end());
if (it->second.size() == 1) {
m_pool->files.erase(it);
int TestMemIoCtxImpl::selfmanaged_snap_remove(uint64_t snapid) {
RWLock::WLocker l(m_pool->file_lock);
- TestMemRadosClient::SnapSeqs::iterator it =
+ TestMemCluster::SnapSeqs::iterator it =
m_pool->snap_seqs.find(snapid);
if (it == m_pool->snap_seqs.end()) {
return -ENOENT;
uint64_t snapid) {
RWLock::WLocker l(m_pool->file_lock);
- TestMemRadosClient::SharedFile file;
- TestMemRadosClient::Files::iterator f_it = m_pool->files.find(oid);
+ TestMemCluster::SharedFile file;
+ TestMemCluster::Files::iterator f_it = m_pool->files.find(oid);
if (f_it == m_pool->files.end()) {
return 0;
}
- TestMemRadosClient::FileSnapshots &snaps = f_it->second;
+ TestMemCluster::FileSnapshots &snaps = f_it->second;
file = snaps.back();
size_t versions = 0;
- for (TestMemRadosClient::FileSnapshots::reverse_iterator it = snaps.rbegin();
+ for (TestMemCluster::FileSnapshots::reverse_iterator it = snaps.rbegin();
it != snaps.rend(); ++it) {
- TestMemRadosClient::SharedFile file = *it;
+ TestMemCluster::SharedFile file = *it;
if (file->snap_id < get_snap_read()) {
if (versions == 0) {
// already at the snapshot version
snaps.erase(it.base());
} else {
// overwrite contents of current HEAD
- file = TestMemRadosClient::SharedFile (new TestMemRadosClient::File(**it));
+ file = TestMemCluster::SharedFile (new TestMemCluster::File(**it));
file->snap_id = CEPH_NOSNAP;
*it = file;
}
} else {
// create new head version
- file = TestMemRadosClient::SharedFile (new TestMemRadosClient::File(**it));
+ file = TestMemCluster::SharedFile (new TestMemCluster::File(**it));
file->snap_id = m_pool->snap_id;
snaps.push_back(file);
}
std::map<uint64_t,uint64_t> *m,
bufferlist *data_bl) {
// TODO verify correctness
- TestMemRadosClient::SharedFile file;
+ TestMemCluster::SharedFile file;
{
RWLock::RLocker l(m_pool->file_lock);
file = get_file(oid, false, get_snap_context());
int TestMemIoCtxImpl::stat(const std::string& oid, uint64_t *psize,
time_t *pmtime) {
- TestMemRadosClient::SharedFile file;
+ TestMemCluster::SharedFile file;
{
RWLock::RLocker l(m_pool->file_lock);
file = get_file(oid, false, get_snap_context());
return -EROFS;
}
- TestMemRadosClient::SharedFile file;
+ TestMemCluster::SharedFile file;
{
RWLock::WLocker l(m_pool->file_lock);
file = get_file(oid, true, snapc);
return -EROFS;
}
- TestMemRadosClient::SharedFile file;
+ TestMemCluster::SharedFile file;
{
RWLock::WLocker l(m_pool->file_lock);
file = get_file(oid, true, snapc);
return -EROFS;
}
- TestMemRadosClient::SharedFile file;
+ TestMemCluster::SharedFile file;
{
RWLock::WLocker l(m_pool->file_lock);
file = get_file(oid, true, snapc);
return -EINVAL;
}
- TestMemRadosClient::SharedFile file;
+ TestMemCluster::SharedFile file;
{
RWLock::WLocker l(m_pool->file_lock);
file = get_file(oid, true, snapc);
int TestMemIoCtxImpl::xattr_get(const std::string& oid,
std::map<std::string, bufferlist>* attrset) {
- TestMemRadosClient::SharedFile file;
+ TestMemCluster::SharedFile file;
RWLock::RLocker l(m_pool->file_lock);
- TestMemRadosClient::FileXAttrs::iterator it = m_pool->file_xattrs.find(oid);
+ TestMemCluster::FileXAttrs::iterator it = m_pool->file_xattrs.find(oid);
if (it == m_pool->file_xattrs.end()) {
return -ENODATA;
}
int TestMemIoCtxImpl::zero(const std::string& oid, uint64_t off, uint64_t len) {
bool truncate_redirect = false;
- TestMemRadosClient::SharedFile file;
+ TestMemCluster::SharedFile file;
{
RWLock::WLocker l(m_pool->file_lock);
file = get_file(oid, false, get_snap_context());
}
}
-TestMemRadosClient::SharedFile TestMemIoCtxImpl::get_file(
+TestMemCluster::SharedFile TestMemIoCtxImpl::get_file(
const std::string &oid, bool write, const SnapContext &snapc) {
assert(m_pool->file_lock.is_locked() || m_pool->file_lock.is_wlocked());
assert(!write || m_pool->file_lock.is_wlocked());
- TestMemRadosClient::SharedFile file;
- TestMemRadosClient::Files::iterator it = m_pool->files.find(oid);
+ TestMemCluster::SharedFile file;
+ TestMemCluster::Files::iterator it = m_pool->files.find(oid);
if (it != m_pool->files.end()) {
file = it->second.back();
} else if (!write) {
- return TestMemRadosClient::SharedFile();
+ return TestMemCluster::SharedFile();
}
if (write) {
bool new_version = false;
if (!file || !file->exists) {
- file = TestMemRadosClient::SharedFile(new TestMemRadosClient::File());
+ file = TestMemCluster::SharedFile(new TestMemCluster::File());
new_version = true;
} else {
if (!snapc.snaps.empty() && file->snap_id < snapc.seq) {
}
bufferlist prev_data = file->data;
- file = TestMemRadosClient::SharedFile(
- new TestMemRadosClient::File(*file));
+ file = TestMemCluster::SharedFile(
+ new TestMemCluster::File(*file));
file->data.clear();
append_clone(prev_data, &file->data);
if (prev_data.length() > 0) {
if (get_snap_read() == CEPH_NOSNAP) {
if (!file->exists) {
assert(it->second.size() > 1);
- return TestMemRadosClient::SharedFile();
+ return TestMemCluster::SharedFile();
}
return file;
}
- TestMemRadosClient::FileSnapshots &snaps = it->second;
- for (TestMemRadosClient::FileSnapshots::reverse_iterator it = snaps.rbegin();
+ TestMemCluster::FileSnapshots &snaps = it->second;
+ for (TestMemCluster::FileSnapshots::reverse_iterator it = snaps.rbegin();
it != snaps.rend(); ++it) {
- TestMemRadosClient::SharedFile file = *it;
+ TestMemCluster::SharedFile file = *it;
if (file->snap_id < get_snap_read()) {
if (!file->exists) {
- return TestMemRadosClient::SharedFile();
+ return TestMemCluster::SharedFile();
}
return file;
}
}
- return TestMemRadosClient::SharedFile();
+ return TestMemCluster::SharedFile();
}
} // namespace librados
#define CEPH_TEST_MEM_IO_CTX_IMPL_H
#include "test/librados_test_stub/TestIoCtxImpl.h"
-#include "test/librados_test_stub/TestMemRadosClient.h"
+#include "test/librados_test_stub/TestMemCluster.h"
namespace librados {
+class TestMemRadosClient;
+
class TestMemIoCtxImpl : public TestIoCtxImpl {
public:
TestMemIoCtxImpl();
TestMemIoCtxImpl(TestMemRadosClient *client, int64_t m_pool_id,
const std::string& pool_name,
- TestMemRadosClient::Pool *pool);
+ TestMemCluster::Pool *pool);
~TestMemIoCtxImpl() override;
TestIoCtxImpl *clone() override;
int selfmanaged_snap_create(uint64_t *snapid) override;
int selfmanaged_snap_remove(uint64_t snapid) override;
int selfmanaged_snap_rollback(const std::string& oid,
- uint64_t snapid) override;
+ uint64_t snapid) override;
int sparse_read(const std::string& oid, uint64_t off, uint64_t len,
- std::map<uint64_t,uint64_t> *m, bufferlist *data_bl) override;
+ std::map<uint64_t,uint64_t> *m, bufferlist *data_bl) override;
int stat(const std::string& oid, uint64_t *psize, time_t *pmtime) override;
int truncate(const std::string& oid, uint64_t size,
- const SnapContext &snapc) override;
+ const SnapContext &snapc) override;
int write(const std::string& oid, bufferlist& bl, size_t len,
- uint64_t off, const SnapContext &snapc) override;
+ uint64_t off, const SnapContext &snapc) override;
int write_full(const std::string& oid, bufferlist& bl,
- const SnapContext &snapc) override;
+ const SnapContext &snapc) override;
int writesame(const std::string& oid, bufferlist& bl, size_t len,
- uint64_t off, const SnapContext &snapc) override;
+ uint64_t off, const SnapContext &snapc) override;
int xattr_get(const std::string& oid,
- std::map<std::string, bufferlist>* attrset) override;
+ std::map<std::string, bufferlist>* attrset) override;
int xattr_set(const std::string& oid, const std::string &name,
- bufferlist& bl) override;
+ bufferlist& bl) override;
int zero(const std::string& oid, uint64_t off, uint64_t len) override;
protected:
- TestMemRadosClient::Pool *get_pool() {
+ TestMemCluster::Pool *get_pool() {
return m_pool;
}
TestMemIoCtxImpl(const TestMemIoCtxImpl&);
TestMemRadosClient *m_client;
- TestMemRadosClient::Pool *m_pool;
+ TestMemCluster::Pool *m_pool;
void append_clone(bufferlist& src, bufferlist* dest);
size_t clip_io(size_t off, size_t len, size_t bl_len);
void ensure_minimum_length(size_t len, bufferlist *bl);
- TestMemRadosClient::SharedFile get_file(const std::string &oid, bool write,
- const SnapContext &snapc);
+ TestMemCluster::SharedFile get_file(const std::string &oid, bool write,
+ const SnapContext &snapc);
};
// vim: ts=8 sw=2 smarttab
#include "test/librados_test_stub/TestMemRadosClient.h"
+#include "test/librados_test_stub/TestMemCluster.h"
#include "test/librados_test_stub/TestMemIoCtxImpl.h"
#include <errno.h>
namespace librados {
-TestMemRadosClient::TestMemRadosClient(CephContext *cct)
- : TestRadosClient(cct), m_pool_id() {
-}
-
-TestMemRadosClient::~TestMemRadosClient() {
- for (Pools::iterator iter = m_pools.begin(); iter != m_pools.end(); ++iter) {
- delete iter->second;
- }
-}
-
-TestMemRadosClient::File::File()
- : snap_id(), exists(true), lock("TestMemRadosClient::File::lock")
-{
-}
-
-TestMemRadosClient::File::File(const File &rhs)
- : data(rhs.data),
- mtime(rhs.mtime),
- snap_id(rhs.snap_id),
- exists(rhs.exists),
- lock("TestMemRadosClient::File::lock")
-{
-}
-
-TestMemRadosClient::Pool::Pool()
- : pool_id(), snap_id(1), file_lock("TestMemRadosClient::Pool::file_lock")
-{
+TestMemRadosClient::TestMemRadosClient(CephContext *cct,
+ TestMemCluster *test_mem_cluster)
+ : TestRadosClient(cct, test_mem_cluster->get_watch_notify()),
+ m_mem_cluster(test_mem_cluster) {
}
TestIoCtxImpl *TestMemRadosClient::create_ioctx(int64_t pool_id,
const std::string &pool_name) {
- return new TestMemIoCtxImpl(this, pool_id, pool_name, get_pool(pool_name));
+ return new TestMemIoCtxImpl(this, pool_id, pool_name,
+ m_mem_cluster->get_pool(pool_name));
}
void TestMemRadosClient::object_list(int64_t pool_id,
std::list<librados::TestRadosClient::Object> *list) {
list->clear();
- for (Pools::iterator p_it = m_pools.begin(); p_it != m_pools.end(); ++p_it) {
- Pool *pool = p_it->second;
- if (pool->pool_id == pool_id) {
- RWLock::RLocker l(pool->file_lock);
- for (Files::iterator it = pool->files.begin();
- it != pool->files.end(); ++it) {
- Object obj;
- obj.oid = it->first;
- list->push_back(obj);
- }
- break;
+ auto pool = m_mem_cluster->get_pool(pool_id);
+ if (pool != nullptr) {
+ RWLock::RLocker file_locker(pool->file_lock);
+ for (auto &file_pair : pool->files) {
+ Object obj;
+ obj.oid = file_pair.first;
+ list->push_back(obj);
}
}
-}
+}
int TestMemRadosClient::pool_create(const std::string &pool_name) {
- if (m_pools.find(pool_name) != m_pools.end()) {
- return -EEXIST;
- }
- Pool *pool = new Pool();
- pool->pool_id = ++m_pool_id;
- m_pools[pool_name] = pool;
- return 0;
+ return m_mem_cluster->pool_create(pool_name);
}
int TestMemRadosClient::pool_delete(const std::string &pool_name) {
- Pools::iterator iter = m_pools.find(pool_name);
- if (iter == m_pools.end()) {
- return -ENOENT;
- }
- iter->second->put();
- m_pools.erase(iter);
- return 0;
+ return m_mem_cluster->pool_delete(pool_name);
}
int TestMemRadosClient::pool_get_base_tier(int64_t pool_id, int64_t* base_tier) {
}
int TestMemRadosClient::pool_list(std::list<std::pair<int64_t, std::string> >& v) {
- v.clear();
- for (Pools::iterator iter = m_pools.begin(); iter != m_pools.end(); ++iter) {
- v.push_back(std::make_pair(iter->second->pool_id, iter->first));
- }
- return 0;
+ return m_mem_cluster->pool_list(v);
}
int64_t TestMemRadosClient::pool_lookup(const std::string &pool_name) {
- Pools::iterator iter = m_pools.find(pool_name);
- if (iter == m_pools.end()) {
- return -ENOENT;
- }
- return iter->second->pool_id;
+ return m_mem_cluster->pool_lookup(pool_name);
}
int TestMemRadosClient::pool_reverse_lookup(int64_t id, std::string *name) {
- for (Pools::iterator iter = m_pools.begin(); iter != m_pools.end(); ++iter) {
- if (iter->second->pool_id == id) {
- *name = iter->first;
- return 0;
- }
- }
- return -ENOENT;
+ return m_mem_cluster->pool_reverse_lookup(id, name);
}
int TestMemRadosClient::watch_flush() {
- get_watch_notify().flush();
+ get_watch_notify()->flush(this);
return 0;
}
return 0;
}
-TestMemRadosClient::Pool *TestMemRadosClient::get_pool(
- const std::string &pool_name) {
- Pools::iterator iter = m_pools.find(pool_name);
- assert(iter != m_pools.end());
- return iter->second;
+void TestMemRadosClient::transaction_start(const std::string &oid) {
+ m_mem_cluster->transaction_start(oid);
+}
+
+void TestMemRadosClient::transaction_finish(const std::string &oid) {
+ m_mem_cluster->transaction_finish(oid);
}
} // namespace librados
#define CEPH_TEST_MEM_RADOS_CLIENT_H
#include "test/librados_test_stub/TestRadosClient.h"
-#include "include/atomic.h"
#include "include/assert.h"
-#include "include/buffer.h"
-#include "include/interval_set.h"
-#include "common/RefCountedObj.h"
-#include "common/RWLock.h"
-#include <boost/shared_ptr.hpp>
#include <list>
-#include <map>
-#include <set>
#include <string>
namespace librados {
class AioCompletionImpl;
+class TestMemCluster;
class TestMemRadosClient : public TestRadosClient {
public:
-
- typedef std::map<std::string, bufferlist> OMap;
- typedef std::map<std::string, OMap> FileOMaps;
- typedef std::map<std::string, bufferlist> FileTMaps;
- typedef std::map<std::string, bufferlist> XAttrs;
- typedef std::map<std::string, XAttrs> FileXAttrs;
-
- struct File {
- File();
- File(const File &rhs);
-
- bufferlist data;
- time_t mtime;
-
- uint64_t snap_id;
- std::vector<uint64_t> snaps;
- interval_set<uint64_t> snap_overlap;
-
- bool exists;
- RWLock lock;
- };
- typedef boost::shared_ptr<File> SharedFile;
-
- typedef std::list<SharedFile> FileSnapshots;
- typedef std::map<std::string, FileSnapshots> Files;
-
- typedef std::set<uint64_t> SnapSeqs;
- struct Pool : public RefCountedObject {
- Pool();
-
- int64_t pool_id;
-
- SnapSeqs snap_seqs;
- uint64_t snap_id;
-
- RWLock file_lock;
- Files files;
- FileOMaps file_omaps;
- FileTMaps file_tmaps;
- FileXAttrs file_xattrs;
- };
-
- TestMemRadosClient(CephContext *cct);
+ TestMemRadosClient(CephContext *cct, TestMemCluster *test_mem_cluster);
TestIoCtxImpl *create_ioctx(int64_t pool_id,
const std::string &pool_name) override;
- void object_list(int64_t pool_id,
- std::list<librados::TestRadosClient::Object> *list) override;
+ void object_list(int64_t pool_id,
+ std::list<librados::TestRadosClient::Object> *list) override;
int pool_create(const std::string &pool_name) override;
int pool_delete(const std::string &pool_name) override;
int watch_flush() override;
int blacklist_add(const std::string& client_address,
- uint32_t expire_seconds) override;
+ uint32_t expire_seconds) override;
protected:
- ~TestMemRadosClient() override;
+ TestMemCluster *get_mem_cluster() {
+ return m_mem_cluster;
+ }
- Pool *get_pool(const std::string &pool_name);
+protected:
+ void transaction_start(const std::string &oid) override;
+ void transaction_finish(const std::string &oid) override;
private:
-
- typedef std::map<std::string, Pool*> Pools;
-
- Pools m_pools;
- int64_t m_pool_id;
+ TestMemCluster *m_mem_cluster;
};
AioCompletionImpl *m_comp;
};
-TestRadosClient::TestRadosClient(CephContext *cct)
- : m_cct(cct->get()),
- m_aio_finisher(new Finisher(m_cct)),
- m_watch_notify(m_cct, m_aio_finisher),
- m_transaction_lock("TestRadosClient::m_transaction_lock")
+TestRadosClient::TestRadosClient(CephContext *cct,
+ TestWatchNotify *watch_notify)
+ : m_cct(cct->get()), m_watch_notify(watch_notify),
+ m_aio_finisher(new Finisher(m_cct))
{
get();
c->get();
Context *ctx = new FunctionContext(boost::bind(
&TestRadosClient::finish_aio_completion, this, c, _1));
- get_watch_notify().aio_flush(ctx);
+ get_watch_notify()->aio_flush(this, ctx);
return 0;
}
return m_finishers[h % m_finishers.size()];
}
-void TestRadosClient::transaction_start(const std::string &oid) {
- Mutex::Locker locker(m_transaction_lock);
- while (m_transactions.count(oid)) {
- m_transaction_cond.Wait(m_transaction_lock);
- }
- std::pair<std::set<std::string>::iterator, bool> result =
- m_transactions.insert(oid);
- assert(result.second);
-}
-
-void TestRadosClient::transaction_finish(const std::string &oid) {
- Mutex::Locker locker(m_transaction_lock);
- size_t count = m_transactions.erase(oid);
- assert(count == 1);
- m_transaction_cond.Signal();
-}
-
} // namespace librados
#include "include/rados/librados.hpp"
#include "common/config.h"
-#include "common/Cond.h"
-#include "common/Mutex.h"
#include "include/atomic.h"
#include "include/buffer_fwd.h"
#include "test/librados_test_stub/TestWatchNotify.h"
#include <boost/functional/hash.hpp>
#include <list>
#include <map>
-#include <set>
#include <string>
#include <vector>
std::string oid;
};
- TestRadosClient(CephContext *cct);
+ TestRadosClient(CephContext *cct, TestWatchNotify *watch_notify);
void get();
void put();
virtual int blacklist_add(const std::string& client_address,
uint32_t expire_seconds) = 0;
- TestWatchNotify &get_watch_notify() {
+ Finisher *get_aio_finisher() {
+ return m_aio_finisher;
+ }
+ TestWatchNotify *get_watch_notify() {
return m_watch_notify;
}
protected:
virtual ~TestRadosClient();
+ virtual void transaction_start(const std::string &oid) = 0;
+ virtual void transaction_finish(const std::string &oid) = 0;
+
private:
CephContext *m_cct;
atomic_t m_refcount;
+ TestWatchNotify *m_watch_notify;
+
Finisher *get_finisher(const std::string& oid);
Finisher *m_aio_finisher;
std::vector<Finisher *> m_finishers;
boost::hash<std::string> m_hash;
- TestWatchNotify m_watch_notify;
-
- Mutex m_transaction_lock;
- Cond m_transaction_cond;
- std::set<std::string> m_transactions;
-
- void transaction_start(const std::string &oid);
- void transaction_finish(const std::string &oid);
-
};
} // namespace librados
#include "test/librados_test_stub/TestWatchNotify.h"
#include "include/Context.h"
#include "common/Finisher.h"
+#include "test/librados_test_stub/TestRadosClient.h"
#include <boost/bind.hpp>
#include <boost/function.hpp>
+#include "include/assert.h"
#define dout_subsys ceph_subsys_rados
#undef dout_prefix
return out;
}
-TestWatchNotify::TestWatchNotify(CephContext *cct, Finisher *finisher)
- : m_cct(cct), m_finisher(finisher), m_handle(), m_notify_id(),
- m_lock("librados::TestWatchNotify::m_lock"),
- m_pending_notifies(0) {
- m_cct->get();
+TestWatchNotify::TestWatchNotify()
+ : m_lock("librados::TestWatchNotify::m_lock") {
}
-TestWatchNotify::~TestWatchNotify() {
- m_cct->put();
-}
+void TestWatchNotify::flush(TestRadosClient *rados_client) {
+ CephContext *cct = rados_client->cct();
-void TestWatchNotify::flush() {
- ldout(m_cct, 20) << "enter" << dendl;
+ ldout(cct, 20) << "enter" << dendl;
// block until we know no additional async notify callbacks will occur
Mutex::Locker locker(m_lock);
while (m_pending_notifies > 0) {
return 0;
}
-void TestWatchNotify::aio_flush(Context *on_finish) {
- m_finisher->queue(on_finish);
+void TestWatchNotify::aio_flush(TestRadosClient *rados_client,
+ Context *on_finish) {
+ rados_client->get_aio_finisher()->queue(on_finish);
}
-void TestWatchNotify::aio_watch(const std::string& o, uint64_t gid,
+void TestWatchNotify::aio_watch(TestRadosClient *rados_client,
+ const std::string& o, uint64_t gid,
uint64_t *handle,
librados::WatchCtx2 *watch_ctx,
Context *on_finish) {
- int r = watch(o, gid, handle, nullptr, watch_ctx);
- m_finisher->queue(on_finish, r);
+ int r = watch(rados_client, o, gid, handle, nullptr, watch_ctx);
+ rados_client->get_aio_finisher()->queue(on_finish, r);
}
-void TestWatchNotify::aio_unwatch(uint64_t handle, Context *on_finish) {
- unwatch(handle);
- m_finisher->queue(on_finish);
+void TestWatchNotify::aio_unwatch(TestRadosClient *rados_client,
+ uint64_t handle, Context *on_finish) {
+ unwatch(rados_client, handle);
+ rados_client->get_aio_finisher()->queue(on_finish);
}
-void TestWatchNotify::aio_notify(const std::string& oid, bufferlist& bl,
+void TestWatchNotify::aio_notify(TestRadosClient *rados_client,
+ const std::string& oid, bufferlist& bl,
uint64_t timeout_ms, bufferlist *pbl,
Context *on_notify) {
+ CephContext *cct = rados_client->cct();
+
Mutex::Locker lock(m_lock);
++m_pending_notifies;
uint64_t notify_id = ++m_notify_id;
- ldout(m_cct, 20) << "oid=" << oid << ": notify_id=" << notify_id << dendl;
+ ldout(cct, 20) << "oid=" << oid << ": notify_id=" << notify_id << dendl;
SharedWatcher watcher = get_watcher(oid);
watcher->notify_handles[notify_id] = notify_handle;
FunctionContext *ctx = new FunctionContext(
- boost::bind(&TestWatchNotify::execute_notify, this, oid, bl, notify_id));
- m_finisher->queue(ctx);
+ boost::bind(&TestWatchNotify::execute_notify, this, rados_client, oid, bl,
+ notify_id));
+ rados_client->get_aio_finisher()->queue(ctx);
}
-int TestWatchNotify::notify(const std::string& oid, bufferlist& bl,
+int TestWatchNotify::notify(TestRadosClient *rados_client,
+ const std::string& oid, bufferlist& bl,
uint64_t timeout_ms, bufferlist *pbl) {
C_SaferCond cond;
- aio_notify(oid, bl, timeout_ms, pbl, &cond);
+ aio_notify(rados_client, oid, bl, timeout_ms, pbl, &cond);
return cond.wait();
}
-void TestWatchNotify::notify_ack(const std::string& o, uint64_t notify_id,
+void TestWatchNotify::notify_ack(TestRadosClient *rados_client,
+ const std::string& o, uint64_t notify_id,
uint64_t handle, uint64_t gid,
bufferlist& bl) {
- ldout(m_cct, 20) << "notify_id=" << notify_id << ", handle=" << handle
- << ", gid=" << gid << dendl;
+ CephContext *cct = rados_client->cct();
+ ldout(cct, 20) << "notify_id=" << notify_id << ", handle=" << handle
+ << ", gid=" << gid << dendl;
Mutex::Locker lock(m_lock);
WatcherID watcher_id = std::make_pair(gid, handle);
- ack_notify(o, notify_id, watcher_id, bl);
- finish_notify(o, notify_id);
+ ack_notify(rados_client, o, notify_id, watcher_id, bl);
+ finish_notify(rados_client, o, notify_id);
}
-int TestWatchNotify::watch(const std::string& o, uint64_t gid,
+int TestWatchNotify::watch(TestRadosClient *rados_client,
+ const std::string& o, uint64_t gid,
uint64_t *handle, librados::WatchCtx *ctx,
librados::WatchCtx2 *ctx2) {
+ CephContext *cct = rados_client->cct();
+
Mutex::Locker lock(m_lock);
SharedWatcher watcher = get_watcher(o);
*handle = watch_handle.handle;
- ldout(m_cct, 20) << "oid=" << o << ", gid=" << gid << ": handle=" << *handle
- << dendl;
+ ldout(cct, 20) << "oid=" << o << ", gid=" << gid << ": handle=" << *handle
+ << dendl;
return 0;
}
-int TestWatchNotify::unwatch(uint64_t handle) {
- ldout(m_cct, 20) << "handle=" << handle << dendl;
+int TestWatchNotify::unwatch(TestRadosClient *rados_client,
+ uint64_t handle) {
+ CephContext *cct = rados_client->cct();
+
+ ldout(cct, 20) << "handle=" << handle << dendl;
Mutex::Locker locker(m_lock);
for (FileWatchers::iterator it = m_file_watchers.begin();
it != m_file_watchers.end(); ++it) {
return watcher;
}
-void TestWatchNotify::execute_notify(const std::string &oid,
+void TestWatchNotify::execute_notify(TestRadosClient *rados_client,
+ const std::string &oid,
bufferlist &bl, uint64_t notify_id) {
- ldout(m_cct, 20) << "oid=" << oid << ", notify_id=" << notify_id << dendl;
+ CephContext *cct = rados_client->cct();
+
+ ldout(cct, 20) << "oid=" << oid << ", notify_id=" << notify_id << dendl;
Mutex::Locker lock(m_lock);
SharedWatcher watcher = get_watcher(oid);
NotifyHandles::iterator n_it = watcher->notify_handles.find(notify_id);
if (n_it == watcher->notify_handles.end()) {
- ldout(m_cct, 1) << "oid=" << oid << ", notify_id=" << notify_id
- << ": not found" << dendl;
+ ldout(cct, 1) << "oid=" << oid << ", notify_id=" << notify_id
+ << ": not found" << dendl;
return;
}
if (watch_handle.watch_ctx2 == NULL) {
// auto ack old-style watch/notify clients
- ack_notify(oid, notify_id, watcher_id, bufferlist());
+ ack_notify(rados_client, oid, notify_id, watcher_id, bufferlist());
}
}
}
- finish_notify(oid, notify_id);
+ finish_notify(rados_client, oid, notify_id);
if (--m_pending_notifies == 0) {
m_file_watcher_cond.Signal();
}
}
-void TestWatchNotify::ack_notify(const std::string &oid,
+void TestWatchNotify::ack_notify(TestRadosClient *rados_client,
+ const std::string &oid,
uint64_t notify_id,
const WatcherID &watcher_id,
const bufferlist &bl) {
- ldout(m_cct, 20) << "oid=" << oid << ", notify_id=" << notify_id
- << ", WatcherID=" << watcher_id << dendl;
+ CephContext *cct = rados_client->cct();
+
+ ldout(cct, 20) << "oid=" << oid << ", notify_id=" << notify_id
+ << ", WatcherID=" << watcher_id << dendl;
assert(m_lock.is_locked());
SharedWatcher watcher = get_watcher(oid);
NotifyHandles::iterator it = watcher->notify_handles.find(notify_id);
if (it == watcher->notify_handles.end()) {
- ldout(m_cct, 1) << "oid=" << oid << ", notify_id=" << notify_id
- << ", WatcherID=" << watcher_id << ": not found" << dendl;
+ ldout(cct, 1) << "oid=" << oid << ", notify_id=" << notify_id
+ << ", WatcherID=" << watcher_id << ": not found" << dendl;
return;
}
notify_handle->pending_watcher_ids.erase(watcher_id);
}
-void TestWatchNotify::finish_notify(const std::string &oid,
+void TestWatchNotify::finish_notify(TestRadosClient *rados_client,
+ const std::string &oid,
uint64_t notify_id) {
- ldout(m_cct, 20) << "oid=" << oid << ", notify_id=" << notify_id << dendl;
+ CephContext *cct = rados_client->cct();
+
+ ldout(cct, 20) << "oid=" << oid << ", notify_id=" << notify_id << dendl;
assert(m_lock.is_locked());
SharedWatcher watcher = get_watcher(oid);
NotifyHandles::iterator it = watcher->notify_handles.find(notify_id);
if (it == watcher->notify_handles.end()) {
- ldout(m_cct, 1) << "oid=" << oid << ", notify_id=" << notify_id
- << ": not found" << dendl;
+ ldout(cct, 1) << "oid=" << oid << ", notify_id=" << notify_id
+ << ": not found" << dendl;
return;
}
SharedNotifyHandle notify_handle = it->second;
if (!notify_handle->pending_watcher_ids.empty()) {
- ldout(m_cct, 10) << "oid=" << oid << ", notify_id=" << notify_id
- << ": pending watchers, returning" << dendl;
+ ldout(cct, 10) << "oid=" << oid << ", notify_id=" << notify_id
+ << ": pending watchers, returning" << dendl;
return;
}
- ldout(m_cct, 20) << "oid=" << oid << ", notify_id=" << notify_id
- << ": completing" << dendl;
+ ldout(cct, 20) << "oid=" << oid << ", notify_id=" << notify_id
+ << ": completing" << dendl;
if (notify_handle->pbl != NULL) {
::encode(notify_handle->notify_responses, *notify_handle->pbl);
#include <list>
#include <map>
-class CephContext;
class Cond;
class Finisher;
namespace librados {
+class TestRadosClient;
+
class TestWatchNotify : boost::noncopyable {
public:
typedef std::pair<uint64_t, uint64_t> WatcherID;
typedef std::map<uint64_t, SharedNotifyHandle> NotifyHandles;
struct WatchHandle {
+ TestRadosClient *rados_client;
uint64_t gid;
uint64_t handle;
librados::WatchCtx* watch_ctx;
};
typedef boost::shared_ptr<Watcher> SharedWatcher;
- TestWatchNotify(CephContext *cct, Finisher *finisher);
- ~TestWatchNotify();
+ TestWatchNotify();
int list_watchers(const std::string& o,
std::list<obj_watch_t> *out_watchers);
- void aio_flush(Context *on_finish);
- void aio_watch(const std::string& o, uint64_t gid, uint64_t *handle,
- librados::WatchCtx2 *watch_ctx, Context *on_finish);
- void aio_unwatch(uint64_t handle, Context *on_finish);
- void aio_notify(const std::string& oid, bufferlist& bl, uint64_t timeout_ms,
- bufferlist *pbl, Context *on_notify);
-
- void flush();
- int notify(const std::string& o, bufferlist& bl,
- uint64_t timeout_ms, bufferlist *pbl);
- void notify_ack(const std::string& o, uint64_t notify_id,
- uint64_t handle, uint64_t gid, bufferlist& bl);
- int watch(const std::string& o, uint64_t gid, uint64_t *handle,
- librados::WatchCtx *ctx, librados::WatchCtx2 *ctx2);
- int unwatch(uint64_t handle);
+ void aio_flush(TestRadosClient *rados_client, Context *on_finish);
+ void aio_watch(TestRadosClient *rados_client, const std::string& o,
+ uint64_t gid, uint64_t *handle, librados::WatchCtx2 *watch_ctx,
+ Context *on_finish);
+ void aio_unwatch(TestRadosClient *rados_client, uint64_t handle,
+ Context *on_finish);
+ void aio_notify(TestRadosClient *rados_client, const std::string& oid,
+ bufferlist& bl, uint64_t timeout_ms, bufferlist *pbl,
+ Context *on_notify);
+
+ void flush(TestRadosClient *rados_client);
+ int notify(TestRadosClient *rados_client, const std::string& o,
+ bufferlist& bl, uint64_t timeout_ms, bufferlist *pbl);
+ void notify_ack(TestRadosClient *rados_client, const std::string& o,
+ uint64_t notify_id, uint64_t handle, uint64_t gid,
+ bufferlist& bl);
+ int watch(TestRadosClient *rados_client, const std::string& o, uint64_t gid,
+ uint64_t *handle, librados::WatchCtx *ctx,
+ librados::WatchCtx2 *ctx2);
+ int unwatch(TestRadosClient *rados_client, uint64_t handle);
private:
typedef std::map<std::string, SharedWatcher> FileWatchers;
- CephContext *m_cct;
- Finisher *m_finisher;
-
- uint64_t m_handle;
- uint64_t m_notify_id;
+ uint64_t m_handle = 0;
+ uint64_t m_notify_id = 0;
Mutex m_lock;
- uint64_t m_pending_notifies;
+ uint64_t m_pending_notifies = 0;
Cond m_file_watcher_cond;
FileWatchers m_file_watchers;
SharedWatcher get_watcher(const std::string& oid);
- void execute_notify(const std::string &oid, bufferlist &bl,
- uint64_t notify_id);
- void ack_notify(const std::string &oid, uint64_t notify_id,
- const WatcherID &watcher_id, const bufferlist &bl);
- void finish_notify(const std::string &oid, uint64_t notify_id);
+ void execute_notify(TestRadosClient *rados_client, const std::string &oid,
+ bufferlist &bl, uint64_t notify_id);
+ void ack_notify(TestRadosClient *rados_client, const std::string &oid,
+ uint64_t notify_id, const WatcherID &watcher_id,
+ const bufferlist &bl);
+ void finish_notify(TestRadosClient *rados_client, const std::string &oid,
+ uint64_t notify_id);
};
} // namespace librados
}
void expect_blacklist_add(MockTestImageCtx &mock_image_ctx, int r) {
- EXPECT_CALL(get_mock_rados_client(), blacklist_add(_, _))
+ EXPECT_CALL(*get_mock_io_ctx(mock_image_ctx.md_ctx).get_mock_rados_client(),
+ blacklist_add(_, _))
.WillOnce(Return(r));
}
#include "test/librbd/test_mock_fixture.h"
#include "test/librbd/mock/MockImageCtx.h"
#include "test/librados_test_stub/LibradosTestStub.h"
-#include "test/librados_test_stub/MockTestMemRadosClient.h"
+#include "test/librados_test_stub/MockTestMemCluster.h"
// template definitions
#include "librbd/AsyncRequest.cc"
using ::testing::StrEq;
using ::testing::WithArg;
-TestMockFixture::TestRadosClientPtr TestMockFixture::s_test_rados_client;
-::testing::NiceMock<librados::MockTestMemRadosClient> *
- TestMockFixture::s_mock_rados_client = NULL;
+TestMockFixture::TestClusterRef TestMockFixture::s_test_cluster;
void TestMockFixture::SetUpTestCase() {
- s_test_rados_client = librados_test_stub::get_rados_client();
+ s_test_cluster = librados_test_stub::get_cluster();
- // use a mock version of the in-memory rados client
- s_mock_rados_client = new ::testing::NiceMock<librados::MockTestMemRadosClient>(
- s_test_rados_client->cct());
- librados_test_stub::set_rados_client(TestRadosClientPtr(s_mock_rados_client));
+ // use a mock version of the in-memory cluster
+ librados_test_stub::set_cluster(boost::shared_ptr<librados::TestCluster>(
+ new librados::MockTestMemCluster()));
TestFixture::SetUpTestCase();
}
void TestMockFixture::TearDownTestCase() {
TestFixture::TearDownTestCase();
- librados_test_stub::set_rados_client(s_test_rados_client);
- s_test_rados_client->put();
- s_test_rados_client.reset();
-}
-
-void TestMockFixture::SetUp() {
- TestFixture::SetUp();
+ librados_test_stub::set_cluster(s_test_cluster);
}
void TestMockFixture::TearDown() {
- TestFixture::TearDown();
-
// Mock rados client lives across tests -- reset it to initial state
- ::testing::Mock::VerifyAndClear(s_mock_rados_client);
- s_mock_rados_client->default_to_dispatch();
+ librados::MockTestMemRadosClient *mock_rados_client =
+ get_mock_io_ctx(m_ioctx).get_mock_rados_client();
+ ASSERT_TRUE(mock_rados_client != nullptr);
+
+ ::testing::Mock::VerifyAndClear(mock_rados_client);
+ mock_rados_client->default_to_dispatch();
+
+ TestFixture::TearDown();
}
void TestMockFixture::expect_unlock_exclusive_lock(librbd::ImageCtx &ictx) {
#include <gmock/gmock.h>
namespace librados {
-class TestRadosClient;
+class TestCluster;
+class MockTestMemCluster;
class MockTestMemIoCtxImpl;
class MockTestMemRadosClient;
}
class TestMockFixture : public TestFixture {
public:
- typedef boost::shared_ptr<librados::TestRadosClient> TestRadosClientPtr;
+ typedef boost::shared_ptr<librados::TestCluster> TestClusterRef;
static void SetUpTestCase();
static void TearDownTestCase();
- void SetUp() override;
void TearDown() override;
- ::testing::NiceMock<librados::MockTestMemRadosClient> &get_mock_rados_client() {
- return *s_mock_rados_client;
- }
-
void expect_op_work_queue(librbd::MockImageCtx &mock_image_ctx);
void expect_unlock_exclusive_lock(librbd::ImageCtx &ictx);
void expect_commit_op_event(librbd::MockImageCtx &mock_image_ctx, int r);
private:
- static TestRadosClientPtr s_test_rados_client;
- static ::testing::NiceMock<librados::MockTestMemRadosClient> *s_mock_rados_client;
+ static TestClusterRef s_test_cluster;
};
#endif // CEPH_TEST_LIBRBD_TEST_MOCK_FIXTURE_H
#include "test/rbd_mirror/test_mock_fixture.h"
#include "include/rbd/librbd.hpp"
#include "test/librados_test_stub/LibradosTestStub.h"
+#include "test/librados_test_stub/MockTestMemCluster.h"
#include "test/librados_test_stub/MockTestMemRadosClient.h"
#include "test/librbd/mock/MockImageCtx.h"
using ::testing::Invoke;
using ::testing::WithArg;
-TestMockFixture::TestRadosClientPtr TestMockFixture::s_test_rados_client;
-::testing::NiceMock<librados::MockTestMemRadosClient> *
- TestMockFixture::s_mock_rados_client = NULL;
+TestMockFixture::TestClusterRef TestMockFixture::s_test_cluster;
void TestMockFixture::SetUpTestCase() {
- s_test_rados_client = librados_test_stub::get_rados_client();
+ s_test_cluster = librados_test_stub::get_cluster();
// use a mock version of the in-memory rados client
- s_mock_rados_client = new ::testing::NiceMock<librados::MockTestMemRadosClient>(
- s_test_rados_client->cct());
- librados_test_stub::set_rados_client(TestRadosClientPtr(s_mock_rados_client));
+ librados_test_stub::set_cluster(boost::shared_ptr<librados::TestCluster>(
+ new librados::MockTestMemCluster()));
TestFixture::SetUpTestCase();
}
void TestMockFixture::TearDownTestCase() {
TestFixture::TearDownTestCase();
- librados_test_stub::set_rados_client(s_test_rados_client);
- s_test_rados_client->put();
- s_test_rados_client.reset();
-}
-
-void TestMockFixture::SetUp() {
- TestFixture::SetUp();
+ librados_test_stub::set_cluster(s_test_cluster);
}
void TestMockFixture::TearDown() {
- TestFixture::TearDown();
-
// Mock rados client lives across tests -- reset it to initial state
- ::testing::Mock::VerifyAndClear(s_mock_rados_client);
- s_mock_rados_client->default_to_dispatch();
+ librados::MockTestMemRadosClient *mock_rados_client =
+ get_mock_io_ctx(m_local_io_ctx).get_mock_rados_client();
+ ASSERT_TRUE(mock_rados_client != nullptr);
+
+ ::testing::Mock::VerifyAndClear(mock_rados_client);
+ mock_rados_client->default_to_dispatch();
+
+ TestFixture::TearDown();
}
void TestMockFixture::expect_test_features(librbd::MockImageCtx &mock_image_ctx) {
#include "common/WorkQueue.h"
#include <boost/shared_ptr.hpp>
#include <gmock/gmock.h>
+#include "include/assert.h"
namespace librados {
class TestRadosClient;
class TestMockFixture : public TestFixture {
public:
- typedef boost::shared_ptr<librados::TestRadosClient> TestRadosClientPtr;
+ typedef boost::shared_ptr<librados::TestCluster> TestClusterRef;
static void SetUpTestCase();
static void TearDownTestCase();
- void SetUp() override;
void TearDown() override;
void expect_test_features(librbd::MockImageCtx &mock_image_ctx);
- ::testing::NiceMock<librados::MockTestMemRadosClient> &get_mock_rados_client() {
- return *s_mock_rados_client;
- }
-
private:
- static TestRadosClientPtr s_test_rados_client;
- static ::testing::NiceMock<librados::MockTestMemRadosClient> *s_mock_rados_client;
+ static TestClusterRef s_test_cluster;
};
} // namespace mirror
m_progress_ctx(progress_ctx),
m_lock(unique_lock_name("ImageCopyRequest::m_lock", this)),
m_updating_sync_point(false), m_update_sync_ctx(nullptr),
- m_update_sync_point_interval(g_ceph_context->_conf->rbd_mirror_sync_point_update_age),
+ m_update_sync_point_interval(m_local_image_ctx->cct->_conf->rbd_mirror_sync_point_update_age),
m_client_meta_copy(*client_meta) {
assert(!m_client_meta_copy.sync_points.empty());
}
projects / ceph.git / commitdiff