cluster.ioctx_create(pool_name.c_str(), ioctx);
bufferlist in, out;
- ASSERT_EQ(0, ioctx.exec("myobject", method::record_hello, in, out));
- ASSERT_EQ(-EEXIST, ioctx.exec("myobject", method::record_hello, in, out));
+ {
+ ObjectWriteOperation write_operation;
+ int rval;
+ write_operation.exec(method::record_hello, in, &out, &rval);
+ ASSERT_EQ(0, ioctx.operate("myobject", &write_operation));
+ ASSERT_EQ(0, rval);
+ }
+ {
+ ObjectWriteOperation write_operation;
+ int rval;
+ write_operation.exec(method::record_hello, in, &out, &rval);
+ ASSERT_EQ(-EEXIST, ioctx.operate("myobject", &write_operation));
+ ASSERT_EQ(-EEXIST, rval);
+ }
in.append("Tester");
- ASSERT_EQ(0, ioctx.exec("myobject2", method::record_hello, in, out));
- ASSERT_EQ(-EEXIST, ioctx.exec("myobject2", method::record_hello, in, out));
- ASSERT_EQ(0u, out.length());
+ {
+ ObjectWriteOperation write_operation;
+ int rval;
+ write_operation.exec(method::record_hello, in, &out, &rval);
+ ASSERT_EQ(0, ioctx.operate("myobject2", &write_operation));
+ ASSERT_EQ(0, rval);
+ }
+
+ {
+ ObjectWriteOperation write_operation;
+ int rval;
+ write_operation.exec(method::record_hello, in, &out, &rval);
+ ASSERT_EQ(-EEXIST, ioctx.operate("myobject2", &write_operation));
+ ASSERT_EQ(-EEXIST, rval);
+ ASSERT_EQ(0u, out.length());
+ }
in.clear();
out.clear();
// this will return nothing -- no flag is set
bufferlist in, out;
- ASSERT_EQ(0, ioctx.exec("myobject", method::write_return_data, in, out));
+ ObjectWriteOperation write_operation;
+ int rval;
+ write_operation.exec(method::write_return_data, in, &out, &rval);
+ ASSERT_EQ(0, ioctx.operate("myobject", &write_operation));
+ ASSERT_EQ(42, rval); // Returned by method.
ASSERT_EQ(std::string(), std::string(out.c_str(), out.length()));
// this will return an error due to unexpected input.
cluster.ioctx_create(pool_name.c_str(), ioctx);
bufferlist in, out;
- ASSERT_EQ(0, ioctx.exec("myobject", method::record_hello, in, out));
+ int rval;
+ {
+ ObjectWriteOperation write_operation;
+ write_operation.exec(method::record_hello, in, &out, &rval);
+ ASSERT_EQ(0, ioctx.operate("myobject", &write_operation));
+ }
ASSERT_EQ(0, ioctx.exec("myobject", method::replay, in, out));
ASSERT_EQ(std::string("Hello, world!"), std::string(out.c_str(), out.length()));
- ASSERT_EQ(0, ioctx.exec("myobject", method::turn_it_to_11, in, out));
+ {
+ ObjectWriteOperation write_operation;
+ write_operation.exec(method::turn_it_to_11, in, &out, &rval);
+ ASSERT_EQ(0, ioctx.operate("myobject", &write_operation));
+ }
ASSERT_EQ(0, ioctx.exec("myobject", method::replay, in, out));
ASSERT_EQ(std::string("HELLO, WORLD!"), std::string(out.c_str(), out.length()));
bufferlist in, out;
ASSERT_EQ(0, ioctx.write_full("myobject", in));
- ASSERT_EQ(-EIO, ioctx.exec("myobject", method::bad_reader, in, out));
+ ObjectWriteOperation write_operation;
+ int rval;
+ write_operation.exec(method::bad_reader, in, &out, &rval);
+ ASSERT_EQ(-EIO, ioctx.operate("myobject", &write_operation));
ASSERT_EQ(-EIO, ioctx.exec("myobject", method::bad_writer, in, out));
ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
bufferlist in, out;
- ASSERT_EQ(-EINVAL, ioctx.exec("myobject", method::add, in, out));
+ int rval;
+ ObjectWriteOperation write_operation;
+ write_operation.exec(method::add, in, &out, &rval);
+ ASSERT_EQ(-EINVAL, ioctx.operate("myobject", &write_operation));
// add a number to a non-existing key
bufferlist in, out;
- ASSERT_EQ(-EINVAL, ioctx.exec("myobject", method::mul, in, out));
+ int rval;
+ ObjectWriteOperation write_operation;
+ write_operation.exec(method::mul, in, &out, &rval);
+ ASSERT_EQ(-EINVAL, ioctx.operate("myobject", &write_operation));
// multiply a number to a non-existing key
123));
bufferlist inbl, outbl;
- ASSERT_EQ(-EINVAL, ioctx.exec(oid, cls::rbd::method::create, inbl, outbl));
+ int rval;
+ librados::ObjectWriteOperation write_operation;
+ write_operation.exec(cls::rbd::method::create, inbl, &outbl, &rval);
+ ASSERT_EQ(-EINVAL, ioctx.operate("myobject", &write_operation));
ioctx.close();
}
#include "test_cxx.h"
#include "crimson_utils.h"
+#include "cls/hello/cls_hello_ops.h"
+
using namespace std;
using namespace librados;
ASSERT_TRUE(my_completion2);
bufferlist in, out;
ASSERT_EQ(0, test_data.m_ioctx.aio_exec(test_data.m_oid, my_completion2.get(),
- "hello", "say_hello", in, &out));
+ cls::hello::method::say_hello, in, &out));
{
TestAlarm alarm;
ASSERT_EQ(0, my_completion2->wait_for_complete());
ASSERT_TRUE(my_completion2);
bufferlist in, out;
ASSERT_EQ(0, test_data.m_ioctx.aio_exec(test_data.m_oid, my_completion2.get(),
- "hello", "say_hello", in, &out));
+ cls::hello::method::say_hello, in, &out));
{
TestAlarm alarm;
ASSERT_EQ(0, my_completion2->wait_for_complete());
using std::ostringstream;
using std::string;
+namespace cls::bogus_classes {
+struct ClassId {
+ static constexpr auto name = "doesnotexistasdfasdf";
+};
+struct ClassIdLock { // This is a real class. We are adding a bogus method.
+ static constexpr auto name = "doesnotexistasdfasdf";
+};
+namespace method {
+constexpr auto bogus_class = ClsMethod<RdTag, ClassId>("method");
+constexpr auto bogus_method = ClsMethod<RdTag, ClassIdLock>("doesnotexistasdfasdfasdf");
+}
+}
+
+using namespace cls::bogus_classes;
+
+// Ignore use of legacy interface, which allows specifying cls methods which do
+// not exist.
TEST(LibRadosCls, DNE) {
Rados cluster;
std::string pool_name = get_temp_pool_name();
ASSERT_EQ(0, ioctx.write(oid, bl, bl.length(), 0));
// call a bogus class
- ASSERT_EQ(-EOPNOTSUPP, ioctx.exec(oid, "doesnotexistasdfasdf", "method", bl, bl));
+ ASSERT_EQ(-EOPNOTSUPP, ioctx.exec(oid, method::bogus_class, bl, bl));
// call a bogus method on existent class
- ASSERT_EQ(-EOPNOTSUPP, ioctx.exec(oid, "lock", "doesnotexistasdfasdfasdf", bl, bl));
+ ASSERT_EQ(-EOPNOTSUPP, ioctx.exec(oid, method::bogus_method, bl, bl));
ioctx.close();
ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
-}
+}
\ No newline at end of file
#include "global/global_context.h"
#include "test/librados/testcase_cxx.h"
#include "test/librados/test_cxx.h"
+#include "cls/version/cls_version_ops.h"
+#include "cls/rbd/cls_rbd_types.h"
#include "crimson_utils.h"
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);
+ int r = ioctx.exec("foo", cls::rbd::method::get_all_features, bl2, out);
ASSERT_EQ(0, r);
auto iter = out.cbegin();
uint64_t all_features;
io_ctx_impl = reinterpret_cast<IoCtxImpl*>(ctx->clone());
}
-int IoCtx::exec(const std::string& oid, const char *cls, const char *method,
+int IoCtx::exec_impl(const std::string& oid, const char *cls, const char *method,
bufferlist& inbl, bufferlist& outbl) {
TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
return ctx->execute_operation(
- oid, std::bind(&TestIoCtxImpl::exec, _1, _2,
+ oid, std::bind(&TestIoCtxImpl::exec_internal, _1, _2,
librados_test_stub::get_class_handler(), cls,
method, inbl, &outbl, ctx->get_snap_read(),
ctx->get_snap_context()));
o->ops.push_back(std::bind(&TestIoCtxImpl::assert_version, _1, _2, ver));
}
-void ObjectOperation::exec(const char *cls, const char *method,
+void ObjectOperation::exec_impl(const char *cls, const char *method,
bufferlist& inbl) {
TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
- o->ops.push_back(std::bind(&TestIoCtxImpl::exec, _1, _2,
+ o->ops.push_back(std::bind(&TestIoCtxImpl::exec_internal, _1, _2,
librados_test_stub::get_class_handler(), cls,
method, inbl, _3, _4, _5));
}
return cls->create(name, handle);
}
-int cls_register_cxx_method(cls_handle_t hclass, const char *method,
+int detail::cls_register_cxx_method_impl(cls_handle_t hclass, const char *method,
int flags,
cls_method_cxx_call_t class_call,
cls_method_handle_t *handle) {
return TestMemIoCtxImpl::cmpext(oid, off, cmp_bl, snap_id);
}
- MOCK_METHOD8(exec, int(const std::string& oid,
+ MOCK_METHOD8(exec_internal, int(const std::string& oid,
TestClassHandler *handler,
const char *cls,
const char *method,
int do_exec(const std::string& oid, TestClassHandler *handler,
const char *cls, const char *method, bufferlist& inbl,
bufferlist* outbl, uint64_t snap_id, const SnapContext &snapc) {
- return TestMemIoCtxImpl::exec(oid, handler, cls, method, inbl, outbl,
+ return TestMemIoCtxImpl::exec_internal(oid, handler, cls, method, inbl, outbl,
snap_id, snapc);
}
ON_CALL(*this, assert_version(_, _)).WillByDefault(Invoke(this, &MockTestMemIoCtxImpl::do_assert_version));
ON_CALL(*this, create(_, _, _)).WillByDefault(Invoke(this, &MockTestMemIoCtxImpl::do_create));
ON_CALL(*this, cmpext(_, _, _, _)).WillByDefault(Invoke(this, &MockTestMemIoCtxImpl::do_cmpext));
- ON_CALL(*this, exec(_, _, _, _, _, _, _, _)).WillByDefault(Invoke(this, &MockTestMemIoCtxImpl::do_exec));
+ ON_CALL(*this, exec_internal(_, _, _, _, _, _, _, _)).WillByDefault(Invoke(this, &MockTestMemIoCtxImpl::do_exec));
ON_CALL(*this, get_instance_id()).WillByDefault(Invoke(this, &MockTestMemIoCtxImpl::do_get_instance_id));
ON_CALL(*this, list_snaps(_, _)).WillByDefault(Invoke(this, &MockTestMemIoCtxImpl::do_list_snaps));
ON_CALL(*this, list_watchers(_, _)).WillByDefault(Invoke(this, &MockTestMemIoCtxImpl::do_list_watchers));
// no-op
}
-void Op::exec(std::string_view cls, std::string_view method,
+void Op::exec_impl(std::string_view cls, std::string_view method,
const ceph::buffer::list& inbl,
ceph::buffer::list* out,
boost::system::error_code* ec) {
[cls_handler, cls, method, inbl = const_cast<bufferlist&>(inbl), out]
(librados::TestIoCtxImpl* io_ctx, const std::string& oid, bufferlist* outbl,
uint64_t snap_id, const SnapContext& snapc, uint64_t*) mutable -> int {
- return io_ctx->exec(
+ return io_ctx->exec_internal(
oid, cls_handler, std::string(cls).c_str(),
std::string(method).c_str(), inbl,
(out != nullptr ? out : outbl), snap_id, snapc);
o->ops.push_back(op);
}
-void Op::exec(std::string_view cls, std::string_view method,
+void Op::exec_impl(std::string_view cls, std::string_view method,
const ceph::buffer::list& inbl,
boost::system::error_code* ec) {
auto o = *reinterpret_cast<librados::TestObjectOperationImpl**>(&impl);
[cls_handler, cls, method, inbl = const_cast<bufferlist&>(inbl)]
(librados::TestIoCtxImpl* io_ctx, const std::string& oid, bufferlist* outbl,
uint64_t snap_id, const SnapContext& snapc, uint64_t*) mutable -> int {
- return io_ctx->exec(
+ return io_ctx->exec_internal(
oid, cls_handler, std::string(cls).c_str(),
std::string(method).c_str(), inbl, outbl, snap_id, snapc);
};
return 0;
}
-int TestIoCtxImpl::exec(const std::string& oid, TestClassHandler *handler,
+int TestIoCtxImpl::exec_internal(const std::string& oid, TestClassHandler *handler,
const char *cls, const char *method,
bufferlist& inbl, bufferlist* outbl,
uint64_t snap_id, const SnapContext &snapc) {
virtual int create(const std::string& oid, bool exclusive,
const SnapContext &snapc) = 0;
- virtual int exec(const std::string& oid, TestClassHandler *handler,
+ virtual int exec_internal(const std::string& oid, TestClassHandler *handler,
const char *cls, const char *method,
bufferlist& inbl, bufferlist* outbl,
uint64_t snap_id, const SnapContext &snapc);
encode(metadata, in_bl);
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("metadata_set"), ContentsEqual(in_bl), _, _, _))
.WillOnce(Return(r));
}
void expect_set_size(librbd::MockTestImageCtx &mock_image_ctx, int r) {
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("set_size"), _, _, _, _))
.WillOnce(Return(r));
}
std::string oid(librbd::ObjectMap<>::object_map_name(mock_image_ctx.id,
snap_id));
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(oid, _, StrEq("rbd"), StrEq("object_map_resize"), _, _, _,
+ exec_internal(oid, _, StrEq("rbd"), StrEq("object_map_resize"), _, _, _,
_))
.WillOnce(Return(r));
}
void expect_add_child(MockImageCtx &mock_image_ctx, int r) {
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(RBD_CHILDREN, _, StrEq("rbd"), StrEq("add_child"), _, _, _,
+ exec_internal(RBD_CHILDREN, _, StrEq("rbd"), StrEq("add_child"), _, _, _,
_))
.WillOnce(Return(r));
}
encode(static_cast<uint64_t>(RBD_OPERATION_FEATURE_CLONE_CHILD), bl);
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(util::header_name(mock_image_ctx.id), _, StrEq("rbd"),
+ exec_internal(util::header_name(mock_image_ctx.id), _, StrEq("rbd"),
StrEq("op_features_set"), ContentsEqual(bl), _, _, _))
.WillOnce(Return(r));
}
bl);
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("child_attach"), ContentsEqual(bl), _, _, _))
.WillOnce(Return(r));
}
void expect_parent_attach(MockImageCtx &mock_image_ctx, int r) {
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("parent_attach"), _, _, _, _))
.WillOnce(Return(r));
}
void expect_set_parent(MockImageCtx &mock_image_ctx, int r) {
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("set_parent"), _, _, _, _))
.WillOnce(Return(r));
}
encode(static_cast<uint32_t>(mirror_mode), out_bl);
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(RBD_MIRRORING, _, StrEq("rbd"), StrEq("mirror_mode_get"),
+ exec_internal(RBD_MIRRORING, _, StrEq("rbd"), StrEq("mirror_mode_get"),
_, _, _, _))
.WillOnce(WithArg<5>(Invoke([out_bl, r](bufferlist* out) {
*out = out_bl;
mock_image_ctx.id}, bl);
EXPECT_CALL(mock_io_ctx_impl,
- exec(util::header_name(parent_spec.image_id),
+ exec_internal(util::header_name(parent_spec.image_id),
_, StrEq("rbd"), StrEq("child_detach"), ContentsEqual(bl),
_, _, _))
.WillOnce(Return(r));
void expect_remove_child(MockImageCtx &mock_image_ctx, int r) {
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(RBD_CHILDREN, _, StrEq("rbd"), StrEq("remove_child"), _,
+ exec_internal(RBD_CHILDREN, _, StrEq("rbd"), StrEq("remove_child"), _,
_, _, _))
.WillOnce(Return(r));
}
using ceph::encode;
EXPECT_CALL(mock_io_ctx_impl,
- exec(parent_header_name, _, StrEq("rbd"),
+ exec_internal(parent_header_name, _, StrEq("rbd"),
StrEq("snapshot_get"), _, _, _, _))
.WillOnce(WithArg<5>(Invoke([snap_info, r](bufferlist* bl) {
encode(snap_info, *bl);
int r) {
using ceph::encode;
EXPECT_CALL(mock_io_ctx_impl,
- exec(RBD_TRASH, _, StrEq("rbd"),
+ exec_internal(RBD_TRASH, _, StrEq("rbd"),
StrEq("trash_get"), _, _, _, _))
.WillOnce(WithArg<5>(Invoke([trash_spec, r](bufferlist* bl) {
encode(trash_spec, *bl);
void expect_parent_detach(MockImageCtx &mock_image_ctx, int r) {
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("parent_detach"), _, _, _, _))
.WillOnce(Return(r));
}
void expect_remove_parent(MockImageCtx &mock_image_ctx, int r) {
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("remove_parent"), _, _, _, _))
.WillOnce(Return(r));
}
}
auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("image_group_get"), _, _, _, _));
if (r < 0) {
expect.WillOnce(Return(r));
void expect_v1_get_snapshots(MockRefreshImageCtx &mock_image_ctx, int r) {
auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("snap_list"), _, _, _, _));
if (r < 0) {
expect.WillOnce(Return(r));
void expect_v1_get_locks(MockRefreshImageCtx &mock_image_ctx, int r) {
auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("lock"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("lock"),
StrEq("get_info"), _, _, _, _));
if (r < 0) {
expect.WillOnce(Return(r));
void expect_get_mutable_metadata(MockRefreshImageCtx &mock_image_ctx,
uint64_t features, int r) {
auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("get_size"), _, _, _, _));
if (r < 0) {
expect.WillOnce(Return(r));
expect.WillOnce(DoDefault());
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("get_features"), _, _, _, _))
.WillOnce(WithArg<5>(Invoke([features, incompatible](bufferlist* out_bl) {
encode(features, *out_bl);
})));
expect_get_flags(mock_image_ctx, 0);
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("get_snapcontext"), _, _, _, _))
.WillOnce(DoDefault());
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("lock"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("lock"),
StrEq("get_info"), _, _, _, _))
.WillOnce(DoDefault());
}
void expect_parent_overlap_get(MockRefreshImageCtx &mock_image_ctx, int r) {
auto& expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("parent_overlap_get"), _, _, _, _));
if (r < 0) {
expect.WillOnce(Return(r));
void expect_get_parent(MockRefreshImageCtx &mock_image_ctx, int r) {
auto& expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("parent_get"), _, _, _, _));
if (r < 0) {
expect.WillOnce(Return(r));
void expect_get_parent_legacy(MockRefreshImageCtx &mock_image_ctx, int r) {
auto& expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("get_parent"), _, _, _, _));
if (r < 0) {
expect.WillOnce(Return(r));
void expect_get_migration_header(MockRefreshImageCtx &mock_image_ctx, int r) {
auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("migration_get"), _, _, _, _));
if (r < 0) {
expect.WillOnce(Return(r));
void expect_get_flags(MockRefreshImageCtx &mock_image_ctx, int r) {
auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("get_flags"), _, _, _, _));
if (r < 0) {
expect.WillOnce(Return(r));
void expect_get_op_features(MockRefreshImageCtx &mock_image_ctx,
uint64_t op_features, int r) {
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("op_features_get"), _, _, _, _))
.WillOnce(WithArg<5>(Invoke([op_features, r](bufferlist* out_bl) {
encode(op_features, *out_bl);
void expect_get_group(MockRefreshImageCtx &mock_image_ctx, int r) {
auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("image_group_get"), _, _, _, _));
if (r < 0) {
expect.WillOnce(Return(r));
void expect_get_snapshots(MockRefreshImageCtx &mock_image_ctx,
bool legacy_parent, int r) {
auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("snapshot_get"), _, _, _, _));
if (r < 0) {
expect.WillOnce(Return(r));
expect.WillOnce(DoDefault());
if (legacy_parent) {
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("get_parent"), _, _, _, _))
.WillOnce(DoDefault());
} else {
}
expect_get_flags(mock_image_ctx, 0);
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("get_protection_status"), _, _, _, _))
.WillOnce(DoDefault());
}
void expect_get_snapshots_legacy(MockRefreshImageCtx &mock_image_ctx,
bool include_timestamp, int r) {
auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("get_snapshot_name"), _, _, _, _));
if (r < 0) {
expect.WillOnce(Return(r));
} else {
expect.WillOnce(DoDefault());
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("get_size"), _, _, _, _))
.WillOnce(DoDefault());
if (include_timestamp) {
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("get_snapshot_timestamp"), _, _, _, _))
.WillOnce(DoDefault());
}
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("get_parent"), _, _, _, _))
.WillOnce(DoDefault());
expect_get_flags(mock_image_ctx, 0);
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("get_protection_status"), _, _, _, _))
.WillOnce(DoDefault());
}
void expect_remove_mirror_image(librados::IoCtx &ioctx, int r) {
EXPECT_CALL(get_mock_io_ctx(ioctx),
- exec(StrEq("rbd_mirroring"), _, StrEq("rbd"),
+ exec_internal(StrEq("rbd_mirroring"), _, StrEq("rbd"),
StrEq("mirror_image_remove"), _, _, _, _))
.WillOnce(Return(r));
}
void expect_dir_remove_image(librados::IoCtx &ioctx, int r) {
EXPECT_CALL(get_mock_io_ctx(ioctx),
- exec(RBD_DIRECTORY, _, StrEq("rbd"), StrEq("dir_remove_image"),
+ exec_internal(RBD_DIRECTORY, _, StrEq("rbd"), StrEq("dir_remove_image"),
_, _, _, _))
.WillOnce(Return(r));
}
auto& mock_io_ctx = librados::get_mock_io_ctx(
mock_image_ctx.rados_api, *mock_image_ctx.get_data_io_context());
EXPECT_CALL(mock_io_ctx,
- exec(oid, _, StrEq("rbd"), StrEq("copyup"),
+ exec_internal(oid, _, StrEq("rbd"), StrEq("copyup"),
ContentsEqual(in_bl), _, _, snapc))
.WillOnce(Return(r));
}
auto& mock_io_ctx = librados::get_mock_io_ctx(
mock_image_ctx.rados_api, *mock_image_ctx.get_data_io_context());
EXPECT_CALL(mock_io_ctx,
- exec(oid, _, StrEq("rbd"), StrEq("sparse_copyup"),
+ exec_internal(oid, _, StrEq("rbd"), StrEq("sparse_copyup"),
ContentsEqual(in_bl), _, _, snapc))
.WillOnce(Return(r));
}
void expect_lock(MockImageCtx &mock_image_ctx, int r,
bool exclusive = true) {
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("lock"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("lock"),
StrEq("lock"), IsLockType(exclusive), _, _, _))
.WillOnce(Return(r));
}
void expect_break_lock(MockTestImageCtx &mock_image_ctx, int r) {
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("lock"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("lock"),
StrEq("break_lock"), _, _, _, _))
.WillOnce(Return(r));
}
const std::string &lock_tag,
ClsLockType lock_type) {
auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("lock"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("lock"),
StrEq("get_info"), _, _, _, _));
if (r < 0 && r != -ENOENT) {
expect.WillOnce(Return(r));
void expect_set_cookie(MockImageCtx &mock_image_ctx, int r,
bool exclusive = true) {
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("lock"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("lock"),
StrEq("set_cookie"), IsLockType(exclusive), _, _, _))
.WillOnce(Return(r));
}
void expect_unlock(MockImageCtx &mock_image_ctx, int r) {
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("lock"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("lock"),
StrEq("unlock"), _, _, _, _))
.WillOnce(Return(r));
}
encode(mirror_image, bl);
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(RBD_MIRRORING, _, StrEq("rbd"), StrEq("mirror_image_get"),
+ exec_internal(RBD_MIRRORING, _, StrEq("rbd"), StrEq("mirror_image_get"),
_, _, _, _))
.WillOnce(DoAll(WithArg<5>(CopyInBufferlist(bl)),
Return(r)));
encode(peers, bl);
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(RBD_MIRRORING, _, StrEq("rbd"), StrEq("mirror_peer_list"),
+ exec_internal(RBD_MIRRORING, _, StrEq("rbd"), StrEq("mirror_peer_list"),
_, _, _, _))
.WillOnce(DoAll(WithArg<5>(CopyInBufferlist(bl)),
Return(r)));
encode(peers, bl);
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(RBD_MIRRORING, _, StrEq("rbd"), StrEq("mirror_peer_list"),
+ exec_internal(RBD_MIRRORING, _, StrEq("rbd"), StrEq("mirror_peer_list"),
_, _, _, _))
.WillOnce(DoAll(WithArg<5>(CopyInBufferlist(bl)),
Return(r)));
ceph::encode(value, out_bl);
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("metadata_get"), ContentsEqual(in_bl), _, _, _))
.WillOnce(DoAll(WithArg<5>(CopyInBufferlist(out_bl)),
Return(r)));
in_bl);
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("metadata_set"), ContentsEqual(in_bl), _, _, _))
.WillOnce(Return(r));
}
encode(peer_uuid, bl);
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("mirror_image_snapshot_unlink_peer"),
ContentsEqual(bl), _, _, _))
.WillOnce(Invoke([&mock_image_ctx, snap_id, peer_uuid, r](auto&&... args) -> int {
encode(clients, bl);
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(::journal::Journaler::header_oid(mock_image_ctx.id),
+ exec_internal(::journal::Journaler::header_oid(mock_image_ctx.id),
_, StrEq("journal"), StrEq("client_list"), _, _, _, _))
.WillOnce(DoAll(WithArg<5>(CopyInBufferlist(bl)),
Return(r)));
encode(client_id, bl);
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(::journal::Journaler::header_oid(mock_image_ctx.id),
+ exec_internal(::journal::Journaler::header_oid(mock_image_ctx.id),
_, StrEq("journal"), StrEq("client_unregister"),
ContentsEqual(bl), _, _, _))
.WillOnce(Return(r));
std::string snap_oid(ObjectMap<>::object_map_name(mock_image_ctx.id,
snap_id));
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(snap_oid, _, StrEq("rbd"), StrEq("object_map_load"), _,
+ exec_internal(snap_oid, _, StrEq("rbd"), StrEq("object_map_load"), _,
_, _, _))
.WillOnce(WithArg<5>(Invoke([object_map, r, lambda=std::move(lambda)]
(bufferlist* out_bl) {
AsyncRequest<> *request = new InvalidateRequest<>(*ictx, CEPH_NOSNAP, true, &cond_ctx);
EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
- exec(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _, _,
+ exec_internal(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _, _,
_, _))
.WillOnce(DoDefault());
AsyncRequest<> *request = new InvalidateRequest<>(*ictx, CEPH_NOSNAP, false, &cond_ctx);
EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
- exec(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _, _,
+ exec_internal(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _, _,
_, _))
.WillOnce(DoDefault());
&cond_ctx);
EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
- exec(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _, _,
+ exec_internal(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _, _,
_, _))
.WillOnce(DoDefault());
AsyncRequest<> *request = new InvalidateRequest<>(*ictx, CEPH_NOSNAP, false, &cond_ctx);
EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
- exec(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _, _,
+ exec_internal(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _, _,
_, _))
.Times(0);
AsyncRequest<> *request = new InvalidateRequest<>(*ictx, CEPH_NOSNAP, false, &cond_ctx);
EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
- exec(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _, _,
+ exec_internal(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _, _,
_, _))
.WillOnce(Return(-EINVAL));
std::string oid(ObjectMap<>::object_map_name(mock_image_ctx.id,
CEPH_NOSNAP));
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(oid, _, StrEq("lock"), StrEq("lock"), _, _, _, _))
+ exec_internal(oid, _, StrEq("lock"), StrEq("lock"), _, _, _, _))
.WillOnce(Return(r));
}
std::string oid(ObjectMap<>::object_map_name(mock_image_ctx.id,
CEPH_NOSNAP));
auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(oid, _, StrEq("lock"), StrEq("get_info"), _,
+ exec_internal(oid, _, StrEq("lock"), StrEq("get_info"), _,
_, _, _));
if (r < 0) {
expect.WillOnce(Return(r));
std::string oid(ObjectMap<>::object_map_name(mock_image_ctx.id,
CEPH_NOSNAP));
auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(oid, _, StrEq("lock"), StrEq("break_lock"),
+ exec_internal(oid, _, StrEq("lock"), StrEq("break_lock"),
_, _, _, _));
if (r < 0) {
expect.WillOnce(Return(r));
int r) {
std::string oid(ObjectMap<>::object_map_name(mock_image_ctx.id, snap_id));
auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(oid, _, StrEq("rbd"),
+ exec_internal(oid, _, StrEq("rbd"),
StrEq("object_map_load"), _, _, _, _));
if (r < 0) {
expect.WillOnce(Return(r));
std::string oid(ObjectMap<>::object_map_name(mock_image_ctx.id,
TEST_SNAP_ID));
auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(oid, _, StrEq("rbd"),
+ exec_internal(oid, _, StrEq("rbd"),
StrEq("object_map_resize"), _, _, _, _));
expect.WillOnce(Return(r));
}
std::string oid(ObjectMap<>::object_map_name(ictx->id, snap_id));
if (snap_id == CEPH_NOSNAP) {
EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
- exec(oid, _, StrEq("lock"), StrEq("assert_locked"), _, _, _,
+ exec_internal(oid, _, StrEq("lock"), StrEq("assert_locked"), _, _, _,
_))
.WillOnce(DoDefault());
}
if (r < 0) {
EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
- exec(oid, _, StrEq("rbd"), StrEq("object_map_resize"), _, _,
+ exec_internal(oid, _, StrEq("rbd"), StrEq("object_map_resize"), _, _,
_, _))
.WillOnce(Return(r));
} else {
EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
- exec(oid, _, StrEq("rbd"), StrEq("object_map_resize"), _, _,
+ exec_internal(oid, _, StrEq("rbd"), StrEq("object_map_resize"), _, _,
_, _))
.WillOnce(DoDefault());
}
void expect_invalidate(librbd::ImageCtx *ictx) {
EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
- exec(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _,
+ exec_internal(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _,
_, _, _))
.WillOnce(DoDefault());
}
std::string oid(ObjectMap<>::object_map_name(ictx->id, CEPH_NOSNAP));
if (r < 0) {
EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
- exec(oid, _, StrEq("lock"), StrEq("assert_locked"), _, _, _,
+ exec_internal(oid, _, StrEq("lock"), StrEq("assert_locked"), _, _, _,
_))
.WillOnce(Return(r));
} else {
EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
- exec(oid, _, StrEq("lock"), StrEq("assert_locked"), _, _, _,
+ exec_internal(oid, _, StrEq("lock"), StrEq("assert_locked"), _, _, _,
_))
.WillOnce(DoDefault());
EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
- exec(oid, _, StrEq("rbd"), StrEq("object_map_snap_add"), _, _,
+ exec_internal(oid, _, StrEq("rbd"), StrEq("object_map_snap_add"), _, _,
_, _))
.WillOnce(DoDefault());
}
void expect_invalidate(librbd::ImageCtx *ictx) {
EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
- exec(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _,
+ exec_internal(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _,
_, _, _))
.WillOnce(DoDefault());
}
std::string snap_oid(ObjectMap<>::object_map_name(ictx->id, snap_id));
if (r < 0) {
EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
- exec(snap_oid, _, StrEq("rbd"), StrEq("object_map_load"), _,
+ exec_internal(snap_oid, _, StrEq("rbd"), StrEq("object_map_load"), _,
_, _, _))
.WillOnce(Return(r));
} else {
EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
- exec(snap_oid, _, StrEq("rbd"), StrEq("object_map_load"), _,
+ exec_internal(snap_oid, _, StrEq("rbd"), StrEq("object_map_load"), _,
_, _, _))
.WillOnce(DoDefault());
}
std::string oid(ObjectMap<>::object_map_name(ictx->id, CEPH_NOSNAP));
if (r < 0) {
EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
- exec(oid, _, StrEq("lock"), StrEq("assert_locked"), _, _, _,
+ exec_internal(oid, _, StrEq("lock"), StrEq("assert_locked"), _, _, _,
_))
.WillOnce(Return(r));
} else {
EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
- exec(oid, _, StrEq("lock"), StrEq("assert_locked"), _, _, _,
+ exec_internal(oid, _, StrEq("lock"), StrEq("assert_locked"), _, _, _,
_))
.WillOnce(DoDefault());
EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
- exec(oid, _, StrEq("rbd"), StrEq("object_map_snap_remove"), _,
+ exec_internal(oid, _, StrEq("rbd"), StrEq("object_map_snap_remove"), _,
_, _, _))
.WillOnce(DoDefault());
}
void expect_invalidate(librbd::ImageCtx *ictx) {
EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
- exec(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _,
+ exec_internal(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _,
_, _, _))
.WillOnce(DoDefault());
}
void expect_write_map(librbd::ImageCtx *ictx, int r) {
EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
- exec(ObjectMap<>::object_map_name(ictx->id, CEPH_NOSNAP), _,
+ exec_internal(ObjectMap<>::object_map_name(ictx->id, CEPH_NOSNAP), _,
StrEq("lock"), StrEq("assert_locked"), _, _, _, _))
.WillOnce(DoDefault());
if (r < 0) {
void expect_invalidate(librbd::ImageCtx *ictx, uint32_t times) {
EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
- exec(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _,
+ exec_internal(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _,
_, _, _))
.Times(times)
.WillRepeatedly(DoDefault());
std::string oid(ObjectMap<>::object_map_name(mock_image_ctx.id,
CEPH_NOSNAP));
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(oid, _, StrEq("lock"), StrEq("unlock"), _, _, _, _))
+ exec_internal(oid, _, StrEq("lock"), StrEq("unlock"), _, _, _, _))
.WillOnce(Return(r));
}
};
std::string oid(ObjectMap<>::object_map_name(ictx->id, snap_id));
if (snap_id == CEPH_NOSNAP) {
EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
- exec(oid, _, StrEq("lock"), StrEq("assert_locked"), _, _, _,
+ exec_internal(oid, _, StrEq("lock"), StrEq("assert_locked"), _, _, _,
_))
.WillOnce(DoDefault());
}
if (r < 0) {
EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
- exec(oid, _, StrEq("rbd"), StrEq("object_map_update"),
+ exec_internal(oid, _, StrEq("rbd"), StrEq("object_map_update"),
ContentsEqual(bl), _, _, _))
.WillOnce(Return(r));
} else {
EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
- exec(oid, _, StrEq("rbd"), StrEq("object_map_update"),
+ exec_internal(oid, _, StrEq("rbd"), StrEq("object_map_update"),
ContentsEqual(bl), _, _, _))
.WillOnce(DoDefault());
}
void expect_invalidate(librbd::ImageCtx *ictx) {
EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
- exec(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _,
+ exec_internal(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _,
_, _, _))
.WillOnce(DoDefault());
}
} else {
expect_is_lock_owner(mock_image_ctx);
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("set_size"), _, _, _, _))
.WillOnce(Return(r));
}
void expect_snap_create(MockImageCtx &mock_image_ctx, int r) {
auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq(mock_image_ctx.old_format ? "snap_add" :
"snapshot_add"),
_, _, _, _));
void expect_set_protection_status(MockImageCtx &mock_image_ctx, int r) {
auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("set_protection_status"), _, _, _,
_));
if (r < 0) {
}
auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("snapshot_trash_add"),
_, _, _, _));
if (r < 0) {
using ceph::encode;
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("snapshot_get"), _, _, _, _))
.WillOnce(WithArg<5>(Invoke([snap_info, r](bufferlist* bl) {
encode(snap_info, *bl);
using ceph::encode;
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("children_list"), _, _, _, _))
.WillOnce(WithArg<5>(Invoke([child_images, r](bufferlist* bl) {
encode(child_images, *bl);
encode(cls::rbd::ChildImageSpec{mock_image_ctx.md_ctx.get_id(), "",
mock_image_ctx.id}, bl);
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(util::header_name(parent_spec.image_id),
+ exec_internal(util::header_name(parent_spec.image_id),
_, StrEq("rbd"), StrEq("child_detach"), ContentsEqual(bl),
_, _, _))
.WillOnce(Return(r));
void expect_snap_remove(MockImageCtx &mock_image_ctx, int r) {
auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq(mock_image_ctx.old_format ? "snap_remove" :
"snapshot_remove"),
_, _, _, _));
encode(status, bl);
auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("set_protection_status"),
ContentsEqual(bl), _, _, _));
if (r < 0) {
encode(children, bl);
auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(RBD_CHILDREN, _, StrEq("rbd"),
+ exec_internal(RBD_CHILDREN, _, StrEq("rbd"),
StrEq("get_children"), _, _, _, _));
if (r < 0) {
expect.WillRepeatedly(Return(r));
void TestMockFixture::expect_unlock_exclusive_lock(librbd::ImageCtx &ictx) {
EXPECT_CALL(get_mock_io_ctx(ictx.md_ctx),
- exec(_, _, StrEq("lock"), StrEq("unlock"), _, _, _, _))
+ exec_internal(_, _, StrEq("lock"), StrEq("unlock"), _, _, _, _))
.WillRepeatedly(DoDefault());
if (ictx.test_features(RBD_FEATURE_DIRTY_CACHE)) {
EXPECT_CALL(get_mock_io_ctx(ictx.md_ctx),
- exec(ictx.header_oid, _, StrEq("rbd"), StrEq("set_features"), _, _, _, _))
+ exec_internal(ictx.header_oid, _, StrEq("rbd"), StrEq("set_features"), _, _, _, _))
.WillOnce(DoDefault());
EXPECT_CALL(get_mock_io_ctx(ictx.md_ctx),
- exec(ictx.header_oid, _, StrEq("rbd"), StrEq("metadata_set"), _, _, _, _))
+ exec_internal(ictx.header_oid, _, StrEq("rbd"), StrEq("metadata_set"), _, _, _, _))
.WillOnce(DoDefault());
EXPECT_CALL(get_mock_io_ctx(ictx.md_ctx),
- exec(ictx.header_oid, _, StrEq("rbd"), StrEq("metadata_remove"), _, _, _, _))
+ exec_internal(ictx.header_oid, _, StrEq("rbd"), StrEq("metadata_remove"), _, _, _, _))
.WillOnce(DoDefault());
}
}
const utime_t& end_time,
int r) {
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(StrEq("rbd_trash"), _, StrEq("rbd"), StrEq("trash_add"),
+ exec_internal(StrEq("rbd_trash"), _, StrEq("rbd"), StrEq("trash_add"),
_, _, _, _))
.WillOnce(WithArg<4>(Invoke([=](bufferlist& in_bl) {
std::string id;
encode(id, in_bl);
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(StrEq("rbd_directory"), _, StrEq("rbd"), StrEq("dir_remove_image"),
+ exec_internal(StrEq("rbd_directory"), _, StrEq("rbd"), StrEq("dir_remove_image"),
ContentsEqual(in_bl), _, _, _))
.WillOnce(Return(r));
}
encode(trash_expect_state, in_bl);
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(StrEq("rbd_trash"), _, StrEq("rbd"), StrEq("trash_state_set"),
+ exec_internal(StrEq("rbd_trash"), _, StrEq("rbd"), StrEq("trash_state_set"),
ContentsEqual(in_bl), _, _, _))
.WillOnce(Return(r));
}
encode(mock_image_ctx.id, in_bl);
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
- exec(StrEq("rbd_trash"), _, StrEq("rbd"), StrEq("trash_remove"),
+ exec_internal(StrEq("rbd_trash"), _, StrEq("rbd"), StrEq("trash_remove"),
ContentsEqual(in_bl), _, _, _))
.WillOnce(Return(r));
}
using neorados::ReadOp;
using neorados::WriteOp;
+namespace cls::bogus_classes {
+struct ClassId {
+ static constexpr auto name = "doesnotexistasdfasdf";
+};
+struct ClassIdLock { // This is a real class. We are adding a bogus method.
+ static constexpr auto name = "doesnotexistasdfasdf";
+};
+namespace method {
+constexpr auto bogus_class = ClsMethod<RdWrTag, ClassId>("method");
+constexpr auto bogus_method = ClsMethod<RdWrTag, ClassIdLock>("doesnotexistasdfasdfasdf");
+}
+}
+
+using namespace ::cls::bogus_classes;
+
CORO_TEST_F(NeoRadosCls, DNE, NeoRadosTest)
{
std::string_view oid = "obj";
co_await execute(oid, WriteOp{}.create(true));
+ bufferlist bl1, bl2;
// Call a bogus class
co_await expect_error_code(
- execute(oid, ReadOp{}.exec("doesnotexistasdfasdf", "method", {})),
+ execute(oid, WriteOp{}.exec(method::bogus_class, std::move(bl1))),
sys::errc::operation_not_supported);
// Call a bogus method on an existent class
co_await expect_error_code(
- execute(oid, ReadOp{}.exec("lock", "doesnotexistasdfasdfasdf", {})),
+ execute(oid, WriteOp{}.exec(method::bogus_method, std::move(bl2))),
sys::errc::operation_not_supported);
co_return;
}
#include "include/neorados/RADOS.hpp"
-#include "cls/version/cls_version_types.h"
+#include "cls/version/cls_version_ops.h"
#include "test/neorados/common_tests.h"
{
neorados::ReadOp op;
- op.exec("version", "read", {},
+ bufferlist bl;
+ op.exec(::cls::version::method::read, std::move(bl),
[](sys::error_code ec, const buffer::list& bl) {
throw buffer::end_of_buffer{};
});
{
neorados::ReadOp op;
- op.exec("version", "read", {},
+ bufferlist bl;
+ op.exec(::cls::version::method::read, std::move(bl),
[](sys::error_code ec, const buffer::list& bl) {
throw std::exception();
});
#include <boost/asio/use_awaitable.hpp>
#include <boost/system/errc.hpp>
+#include <cls/rbd/cls_rbd_ops.h>
#include "include/neorados/RADOS.hpp"
}
CORO_TEST_F(NeoRadosMisc, Exec, NeoRadosTest) {
- buffer::list out;
+ buffer::list in, out;
co_await execute(oid, WriteOp{}.create(true));
co_await execute(oid,
- ReadOp{}.exec("rbd"sv, "get_all_features"sv, {}, &out));
+ ReadOp{}.exec(::cls::rbd::method::get_all_features, std::move(in), &out));
auto features = from_buffer_list<std::uint64_t>(out);
// make sure *some* features are specified; don't care which ones
EXPECT_NE(0, features);
#include "gtest/gtest.h"
+#include "cls/rbd/cls_rbd_ops.h"
+
namespace asio = boost::asio;
namespace ctnr = boost::container;
namespace hash_alg = neorados::hash_alg;
CORO_TEST_F(NeoRadosReadOps, SetOpFlags, ReadOpTest) {
sys::error_code ec;
+ bufferlist bl;
co_await execute(oid, ReadOp{}
- .exec("rbd"sv, "get_id"sv, {}, nullptr, &ec)
+ .exec(::cls::rbd::method::get_id, std::move(bl), nullptr, &ec)
.set_failok());
EXPECT_EQ(sys::errc::io_error, ec);
co_return;
}
CORO_TEST_F(NeoRadosReadOps, Exec, ReadOpTest) {
- buffer::list bl;
+ buffer::list bl, inbl;
sys::error_code ec;
co_await execute(oid,
- ReadOp{}.exec("rbd"sv, "get_all_features"sv, {}, &bl, &ec));
+ ReadOp{}.exec(::cls::rbd::method::get_all_features, std::move(inbl), &bl, &ec));
EXPECT_FALSE(ec);
std::uint64_t features;
EXPECT_EQ(sizeof(features), bl.length());
#include "gtest/gtest.h"
+#include "cls/hello/cls_hello_ops.h"
+
namespace sys = boost::system;
using namespace std::literals;
CORO_TEST_F(NeoRadosWriteOps, Exec, NeoRadosTest) {
co_await execute(oid, WriteOp{}
- .exec("hello"sv, "record_hello"sv,
- to_buffer_list("test")));
+ .exec(::cls::hello::method::record_hello, to_buffer_list("test")));
const auto bl = co_await read(oid);
EXPECT_EQ(to_buffer_list("Hello, test!"), bl);
co_return;
encode(image_id, bl);
EXPECT_CALL(get_mock_io_ctx(m_local_io_ctx),
- exec(RBD_MIRRORING, _, StrEq("rbd"),
+ exec_internal(RBD_MIRRORING, _, StrEq("rbd"),
StrEq("mirror_image_get_image_id"), _, _, _, _))
.WillOnce(DoAll(WithArg<5>(Invoke([bl](bufferlist *out_bl) {
*out_bl = bl;
encode(mirror_image, bl);
EXPECT_CALL(get_mock_io_ctx(m_local_io_ctx),
- exec(RBD_MIRRORING, _, StrEq("rbd"),
+ exec_internal(RBD_MIRRORING, _, StrEq("rbd"),
StrEq("mirror_image_set"), ContentsEqual(bl), _, _, _))
.WillOnce(Return(r));
}
void expect_trash_get(const cls::rbd::TrashImageSpec& trash_spec, int r) {
using ceph::encode;
EXPECT_CALL(get_mock_io_ctx(m_local_io_ctx),
- exec(StrEq(RBD_TRASH), _, StrEq("rbd"),
+ exec_internal(StrEq(RBD_TRASH), _, StrEq("rbd"),
StrEq("trash_get"), _, _, _, _))
.WillOnce(WithArg<5>(Invoke([trash_spec, r](bufferlist* bl) {
encode(trash_spec, *bl);
encode(cls::rbd::TRASH_IMAGE_STATE_NORMAL, in_bl);
EXPECT_CALL(get_mock_io_ctx(m_local_io_ctx),
- exec(StrEq(RBD_TRASH), _, StrEq("rbd"),
+ exec_internal(StrEq(RBD_TRASH), _, StrEq("rbd"),
StrEq("trash_state_set"),
ContentsEqual(in_bl), _, _, _))
.WillOnce(Return(r));
encode(snapc, bl);
EXPECT_CALL(get_mock_io_ctx(m_local_io_ctx),
- exec(librbd::util::header_name(image_id), _, StrEq("rbd"),
+ exec_internal(librbd::util::header_name(image_id), _, StrEq("rbd"),
StrEq("get_snapcontext"), _, _, _, _))
.WillOnce(DoAll(WithArg<5>(Invoke([bl](bufferlist *out_bl) {
*out_bl = bl;
encode(images, out_bl);
EXPECT_CALL(get_mock_io_ctx(io_ctx),
- exec(RBD_TRASH, _, StrEq("rbd"), StrEq("trash_list"),
+ exec_internal(RBD_TRASH, _, StrEq("rbd"), StrEq("trash_list"),
ContentsEqual(bl), _, _, _))
.WillOnce(DoAll(WithArg<5>(Invoke([out_bl](bufferlist *bl) {
*bl = out_bl;
bufferlist bl;
ceph::encode(key, bl);
EXPECT_CALL(get_mock_io_ctx(m_mock_local_image_ctx->md_ctx),
- exec(m_mock_local_image_ctx->header_oid, _, StrEq("rbd"),
+ exec_internal(m_mock_local_image_ctx->header_oid, _, StrEq("rbd"),
StrEq("metadata_remove"), ContentsEqual(bl), _, _, _))
.WillOnce(Return(r));
if (r < 0) {
bufferlist bl;
ceph::encode(pairs, bl);
EXPECT_CALL(get_mock_io_ctx(m_mock_local_image_ctx->md_ctx),
- exec(m_mock_local_image_ctx->header_oid, _, StrEq("rbd"),
+ exec_internal(m_mock_local_image_ctx->header_oid, _, StrEq("rbd"),
StrEq("metadata_set"), ContentsEqual(bl), _, _, _))
.WillOnce(Return(r));
}
encode(mirror_image, bl);
EXPECT_CALL(get_mock_io_ctx(m_local_io_ctx),
- exec(RBD_MIRRORING, _, StrEq("rbd"),
+ exec_internal(RBD_MIRRORING, _, StrEq("rbd"),
StrEq("mirror_image_set"), ContentsEqual(bl), _, _, _))
.WillOnce(Return(r));
}
encode(image_id, bl);
EXPECT_CALL(get_mock_io_ctx(m_local_io_ctx),
- exec(StrEq("rbd_mirroring"), _, StrEq("rbd"),
+ exec_internal(StrEq("rbd_mirroring"), _, StrEq("rbd"),
StrEq("mirror_image_remove"),
ContentsEqual(bl), _, _, _))
.WillOnce(Return(r));
encode(last_copied_object, bl);
EXPECT_CALL(get_mock_io_ctx(mock_test_image_ctx.md_ctx),
- exec(mock_test_image_ctx.header_oid, _, StrEq("rbd"),
+ exec_internal(mock_test_image_ctx.header_oid, _, StrEq("rbd"),
StrEq("mirror_image_snapshot_set_copy_progress"),
ContentsEqual(bl), _, _, _))
.WillOnce(Return(r));
encode(mirror_image, bl);
EXPECT_CALL(get_mock_io_ctx(io_ctx),
- exec(RBD_MIRRORING, _, StrEq("rbd"), StrEq("mirror_image_get"),
+ exec_internal(RBD_MIRRORING, _, StrEq("rbd"), StrEq("mirror_image_get"),
_, _, _, _))
.WillOnce(DoAll(WithArg<5>(Invoke([bl](bufferlist *out_bl) {
*out_bl = bl;
encode(image_id, bl);
EXPECT_CALL(get_mock_io_ctx(io_ctx),
- exec(RBD_MIRRORING, _, StrEq("rbd"),
+ exec_internal(RBD_MIRRORING, _, StrEq("rbd"),
StrEq("mirror_image_get_image_id"), _, _, _, _))
.WillOnce(DoAll(WithArg<5>(Invoke([bl](bufferlist *out_bl) {
*out_bl = bl;
encode(image_id, bl);
EXPECT_CALL(get_mock_io_ctx(io_ctx),
- exec(RBD_MIRRORING, _, StrEq("rbd"),
+ exec_internal(RBD_MIRRORING, _, StrEq("rbd"),
StrEq("mirror_image_get_image_id"), _, _, _, _))
.WillOnce(DoAll(WithArg<5>(Invoke([bl](bufferlist *out_bl) {
*out_bl = bl;
encode(image_name, bl);
EXPECT_CALL(get_mock_io_ctx(io_ctx),
- exec(RBD_DIRECTORY, _, StrEq("rbd"), StrEq("dir_get_name"), _,
+ exec_internal(RBD_DIRECTORY, _, StrEq("rbd"), StrEq("dir_get_name"), _,
_, _, _))
.WillOnce(DoAll(WithArg<5>(Invoke([bl](bufferlist *out_bl) {
*out_bl = bl;
encode(ids, bl);
EXPECT_CALL(get_mock_io_ctx(io_ctx),
- exec(RBD_MIRRORING, _, StrEq("rbd"), StrEq("mirror_image_list"),
+ exec_internal(RBD_MIRRORING, _, StrEq("rbd"), StrEq("mirror_image_list"),
_, _, _, _))
.WillOnce(DoAll(WithArg<5>(Invoke([bl](bufferlist *out_bl) {
*out_bl = bl;
void expect_register_instance(librados::MockTestMemIoCtxImpl &mock_io_ctx,
int r) {
- EXPECT_CALL(mock_io_ctx, exec(RBD_MIRROR_LEADER, _, StrEq("rbd"),
+ EXPECT_CALL(mock_io_ctx, exec_internal(RBD_MIRROR_LEADER, _, StrEq("rbd"),
StrEq("mirror_instances_add"), _, _, _, _))
.WillOnce(Return(r));
}
void expect_unregister_instance(librados::MockTestMemIoCtxImpl &mock_io_ctx,
int r) {
- EXPECT_CALL(mock_io_ctx, exec(RBD_MIRROR_LEADER, _, StrEq("rbd"),
+ EXPECT_CALL(mock_io_ctx, exec_internal(RBD_MIRROR_LEADER, _, StrEq("rbd"),
StrEq("mirror_instances_remove"), _, _, _, _))
.WillOnce(Return(r));
}
const std::string& global_image_id,
const cls::rbd::MirrorImageSiteStatus& mirror_image_status, int r) {
EXPECT_CALL(*m_mock_local_io_ctx,
- exec(RBD_MIRRORING, _, StrEq("rbd"),
+ exec_internal(RBD_MIRRORING, _, StrEq("rbd"),
StrEq("mirror_image_status_set"), _, _, _, _))
.WillOnce(WithArg<4>(Invoke(
[r, global_image_id, mirror_image_status](bufferlist& in_bl) {
void expect_mirror_status_remove(const std::string& global_image_id, int r) {
EXPECT_CALL(*m_mock_local_io_ctx,
- exec(RBD_MIRRORING, _, StrEq("rbd"),
+ exec_internal(RBD_MIRRORING, _, StrEq("rbd"),
StrEq("mirror_image_status_remove"), _, _, _, _))
.WillOnce(WithArg<4>(Invoke(
[r, global_image_id](bufferlist& in_bl) {
encode(uuid, out_bl);
EXPECT_CALL(*io_ctx_impl,
- exec(RBD_MIRRORING, _, StrEq("rbd"), StrEq("mirror_uuid_get"),
+ exec_internal(RBD_MIRRORING, _, StrEq("rbd"), StrEq("mirror_uuid_get"),
_, _, _, _))
.WillOnce(DoAll(WithArg<5>(Invoke([out_bl](bufferlist *bl) {
*bl = out_bl;
std::atomic<bool>* default_namespace_enabled,
int r) {
EXPECT_CALL(*io_ctx_impl,
- exec(RBD_MIRRORING, _, StrEq("rbd"), StrEq("mirror_mode_get"),
+ exec_internal(RBD_MIRRORING, _, StrEq("rbd"), StrEq("mirror_mode_get"),
_, _, _, _))
.WillRepeatedly(DoAll(WithArg<5>(Invoke(
[io_ctx_impl, default_namespace_enabled](bufferlist* bl) {
librados::MockTestMemIoCtxImpl *io_ctx_impl,
const std::string &remote_namespace, int r) {
EXPECT_CALL(*io_ctx_impl,
- exec(RBD_MIRRORING, _, StrEq("rbd"),
+ exec_internal(RBD_MIRRORING, _, StrEq("rbd"),
StrEq("mirror_remote_namespace_get"), _, _, _, _))
.WillRepeatedly(DoAll(WithArg<5>(Invoke([remote_namespace](bufferlist *bl) {
encode(remote_namespace, *bl);
projects / ceph-ci.git / commitdiff