#include "include/scope_guard.h"
#include "include/types.h"
#include "include/rados/librados.hpp"
+#include "common/ceph_context.h"
#include "cls/fifo/cls_fifo_ops.h"
#include "test/librados/test_cxx.h"
namespace fifo = rados::cls::fifo;
namespace RCf = rgw::cls::fifo;
+auto cct = new CephContext(CEPH_ENTITY_TYPE_CLIENT);
+const DoutPrefix dp(cct, 1, "test legacy cls fifo: ");
+
namespace {
-int fifo_create(R::IoCtx& ioctx,
+int fifo_create(const DoutPrefixProvider *dpp, R::IoCtx& ioctx,
const std::string& oid,
std::string_view id,
optional_yield y,
R::ObjectWriteOperation op;
RCf::create_meta(&op, id, objv, oid_prefix, exclusive, max_part_size,
max_entry_size);
- return rgw_rados_operate(ioctx, oid, &op, y);
+ return rgw_rados_operate(dpp, ioctx, oid, &op, y);
}
}
TEST_F(LegacyClsFIFO, TestCreate)
{
- auto r = fifo_create(ioctx, fifo_id, ""s, null_yield);
+ auto r = fifo_create(&dp, ioctx, fifo_id, ""s, null_yield);
EXPECT_EQ(-EINVAL, r);
- r = fifo_create(ioctx, fifo_id, fifo_id, null_yield, std::nullopt,
+ r = fifo_create(&dp, ioctx, fifo_id, fifo_id, null_yield, std::nullopt,
std::nullopt, false, 0);
EXPECT_EQ(-EINVAL, r);
- r = fifo_create(ioctx, fifo_id, {}, null_yield,
+ r = fifo_create(&dp, ioctx, fifo_id, {}, null_yield,
std::nullopt, std::nullopt,
false, RCf::default_max_part_size, 0);
EXPECT_EQ(-EINVAL, r);
- r = fifo_create(ioctx, fifo_id, fifo_id, null_yield);
+ r = fifo_create(&dp, ioctx, fifo_id, fifo_id, null_yield);
EXPECT_EQ(0, r);
std::uint64_t size;
ioctx.stat(fifo_id, &size, nullptr);
EXPECT_GT(size, 0);
/* test idempotency */
- r = fifo_create(ioctx, fifo_id, fifo_id, null_yield);
+ r = fifo_create(&dp, ioctx, fifo_id, fifo_id, null_yield);
EXPECT_EQ(0, r);
- r = fifo_create(ioctx, fifo_id, {}, null_yield, std::nullopt,
+ r = fifo_create(&dp, ioctx, fifo_id, {}, null_yield, std::nullopt,
std::nullopt, false);
EXPECT_EQ(-EINVAL, r);
- r = fifo_create(ioctx, fifo_id, {}, null_yield, std::nullopt,
+ r = fifo_create(&dp, ioctx, fifo_id, {}, null_yield, std::nullopt,
"myprefix"sv, false);
EXPECT_EQ(-EINVAL, r);
- r = fifo_create(ioctx, fifo_id, "foo"sv, null_yield,
+ r = fifo_create(&dp, ioctx, fifo_id, "foo"sv, null_yield,
std::nullopt, std::nullopt, false);
EXPECT_EQ(-EEXIST, r);
}
TEST_F(LegacyClsFIFO, TestGetInfo)
{
- auto r = fifo_create(ioctx, fifo_id, fifo_id, null_yield);
+ auto r = fifo_create(&dp, ioctx, fifo_id, fifo_id, null_yield);
fifo::info info;
std::uint32_t part_header_size;
std::uint32_t part_entry_overhead;
- r = RCf::get_meta(ioctx, fifo_id, std::nullopt, &info, &part_header_size,
+ r = RCf::get_meta(&dp, ioctx, fifo_id, std::nullopt, &info, &part_header_size,
&part_entry_overhead, 0, null_yield);
EXPECT_EQ(0, r);
EXPECT_GT(part_header_size, 0);
EXPECT_GT(part_entry_overhead, 0);
EXPECT_FALSE(info.version.instance.empty());
- r = RCf::get_meta(ioctx, fifo_id, info.version, &info, &part_header_size,
+ r = RCf::get_meta(&dp, ioctx, fifo_id, info.version, &info, &part_header_size,
&part_entry_overhead, 0, null_yield);
EXPECT_EQ(0, r);
fifo::objv objv;
objv.instance = "foo";
objv.ver = 12;
- r = RCf::get_meta(ioctx, fifo_id, objv, &info, &part_header_size,
+ r = RCf::get_meta(&dp, ioctx, fifo_id, objv, &info, &part_header_size,
&part_entry_overhead, 0, null_yield);
EXPECT_EQ(-ECANCELED, r);
}
TEST_F(LegacyFIFO, TestOpenDefault)
{
std::unique_ptr<RCf::FIFO> fifo;
- auto r = RCf::FIFO::create(ioctx, fifo_id, &fifo, null_yield);
+ auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &fifo, null_yield);
ASSERT_EQ(0, r);
// force reading from backend
- r = fifo->read_meta(null_yield);
+ r = fifo->read_meta(&dp, null_yield);
EXPECT_EQ(0, r);
auto info = fifo->meta();
EXPECT_EQ(info.id, fifo_id);
/* first successful create */
std::unique_ptr<RCf::FIFO> f;
- auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield, objv, oid_prefix,
+ auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield, objv, oid_prefix,
false, max_part_size, max_entry_size);
ASSERT_EQ(0, r);
/* force reading from backend */
- r = f->read_meta(null_yield);
+ r = f->read_meta(&dp, null_yield);
auto info = f->meta();
EXPECT_EQ(info.id, fifo_id);
EXPECT_EQ(info.params.max_part_size, max_part_size);
TEST_F(LegacyFIFO, TestPushListTrim)
{
std::unique_ptr<RCf::FIFO> f;
- auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield);
+ auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield);
ASSERT_EQ(0, r);
static constexpr auto max_entries = 10u;
for (uint32_t i = 0; i < max_entries; ++i) {
cb::list bl;
encode(i, bl);
- r = f->push(bl, null_yield);
+ r = f->push(&dp, bl, null_yield);
ASSERT_EQ(0, r);
}
bool more = false;
for (auto i = 0u; i < max_entries; ++i) {
- r = f->list(1, marker, &result, &more, null_yield);
+ r = f->list(&dp, 1, marker, &result, &more, null_yield);
ASSERT_EQ(0, r);
bool expected_more = (i != (max_entries - 1));
/* get all entries at once */
std::string markers[max_entries];
std::uint32_t min_entry = 0;
- r = f->list(max_entries * 10, std::nullopt, &result, &more, null_yield);
+ r = f->list(&dp, max_entries * 10, std::nullopt, &result, &more, null_yield);
ASSERT_EQ(0, r);
ASSERT_FALSE(more);
}
/* trim one entry */
- r = f->trim(markers[min_entry], false, null_yield);
+ r = f->trim(&dp, markers[min_entry], false, null_yield);
ASSERT_EQ(0, r);
++min_entry;
- r = f->list(max_entries * 10, std::nullopt, &result, &more, null_yield);
+ r = f->list(&dp, max_entries * 10, std::nullopt, &result, &more, null_yield);
ASSERT_EQ(0, r);
ASSERT_FALSE(more);
ASSERT_EQ(max_entries - min_entry, result.size());
static constexpr auto max_entry_size = 128ull;
std::unique_ptr<RCf::FIFO> f;
- auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield, std::nullopt,
+ auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield, std::nullopt,
std::nullopt, false, max_part_size, max_entry_size);
ASSERT_EQ(0, r);
cb::list bl;
bl.append(buf, sizeof(buf));
- r = f->push(bl, null_yield);
+ r = f->push(&dp, bl, null_yield);
EXPECT_EQ(-E2BIG, r);
}
static constexpr auto max_part_size = 2048ull;
static constexpr auto max_entry_size = 128ull;
std::unique_ptr<RCf::FIFO> f;
- auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield, std::nullopt,
+ auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield, std::nullopt,
std::nullopt, false, max_part_size,
max_entry_size);
ASSERT_EQ(0, r);
cb::list bl;
*(int *)buf = i;
bl.append(buf, sizeof(buf));
- r = f->push(bl, null_yield);
+ r = f->push(&dp, bl, null_yield);
ASSERT_EQ(0, r);
}
/* list all at once */
std::vector<RCf::list_entry> result;
bool more = false;
- r = f->list(max_entries, std::nullopt, &result, &more, null_yield);
+ r = f->list(&dp, max_entries, std::nullopt, &result, &more, null_yield);
ASSERT_EQ(0, r);
EXPECT_EQ(false, more);
ASSERT_EQ(max_entries, result.size());
/* get entries one by one */
for (auto i = 0u; i < max_entries; ++i) {
- r = f->list(1, marker, &result, &more, null_yield);
+ r = f->list(&dp, 1, marker, &result, &more, null_yield);
ASSERT_EQ(0, r);
ASSERT_EQ(result.size(), 1);
const bool expected_more = (i != (max_entries - 1));
marker.reset();
for (auto i = 0u; i < max_entries; ++i) {
/* read single entry */
- r = f->list(1, marker, &result, &more, null_yield);
+ r = f->list(&dp, 1, marker, &result, &more, null_yield);
ASSERT_EQ(0, r);
ASSERT_EQ(result.size(), 1);
const bool expected_more = (i != (max_entries - 1));
ASSERT_EQ(expected_more, more);
marker = result.front().marker;
- r = f->trim(*marker, false, null_yield);
+ r = f->trim(&dp, *marker, false, null_yield);
ASSERT_EQ(0, r);
/* check tail */
ASSERT_EQ(info.tail_part_num, i / entries_per_part);
/* try to read all again, see how many entries left */
- r = f->list(max_entries, marker, &result, &more, null_yield);
+ r = f->list(&dp, max_entries, marker, &result, &more, null_yield);
ASSERT_EQ(max_entries - i - 1, result.size());
ASSERT_EQ(false, more);
}
RCf::part_info partinfo;
/* check old tails are removed */
for (auto i = 0; i < info.tail_part_num; ++i) {
- r = f->get_part_info(i, &partinfo, null_yield);
+ r = f->get_part_info(&dp, i, &partinfo, null_yield);
ASSERT_EQ(-ENOENT, r);
}
/* check current tail exists */
- r = f->get_part_info(info.tail_part_num, &partinfo, null_yield);
+ r = f->get_part_info(&dp, info.tail_part_num, &partinfo, null_yield);
ASSERT_EQ(0, r);
}
static constexpr auto max_entry_size = 128ull;
std::unique_ptr<RCf::FIFO> f;
- auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield, std::nullopt,
+ auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield, std::nullopt,
std::nullopt, false, max_part_size,
max_entry_size);
ASSERT_EQ(0, r);
(max_entry_size + part_entry_overhead));
const auto max_entries = entries_per_part * 4 + 1;
std::unique_ptr<RCf::FIFO> f2;
- r = RCf::FIFO::open(ioctx, fifo_id, &f2, null_yield);
+ r = RCf::FIFO::open(&dp, ioctx, fifo_id, &f2, null_yield);
std::vector fifos{&f, &f2};
for (auto i = 0u; i < max_entries; ++i) {
*(int *)buf = i;
bl.append(buf, sizeof(buf));
auto& f = *fifos[i % fifos.size()];
- r = f->push(bl, null_yield);
+ r = f->push(&dp, bl, null_yield);
ASSERT_EQ(0, r);
}
/* list all by both */
std::vector<RCf::list_entry> result;
bool more = false;
- r = f2->list(max_entries, std::nullopt, &result, &more, null_yield);
+ r = f2->list(&dp, max_entries, std::nullopt, &result, &more, null_yield);
ASSERT_EQ(0, r);
ASSERT_EQ(false, more);
ASSERT_EQ(max_entries, result.size());
- r = f2->list(max_entries, std::nullopt, &result, &more, null_yield);
+ r = f2->list(&dp, max_entries, std::nullopt, &result, &more, null_yield);
ASSERT_EQ(0, r);
ASSERT_EQ(false, more);
ASSERT_EQ(max_entries, result.size());
static constexpr auto max_part_size = 2048ull;
static constexpr auto max_entry_size = 128ull;
std::unique_ptr<RCf::FIFO> f1;
- auto r = RCf::FIFO::create(ioctx, fifo_id, &f1, null_yield, std::nullopt,
+ auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f1, null_yield, std::nullopt,
std::nullopt, false, max_part_size,
max_entry_size);
ASSERT_EQ(0, r);
const auto max_entries = entries_per_part * 4 + 1;
std::unique_ptr<RCf::FIFO> f2;
- r = RCf::FIFO::open(ioctx, fifo_id, &f2, null_yield);
+ r = RCf::FIFO::open(&dp, ioctx, fifo_id, &f2, null_yield);
ASSERT_EQ(0, r);
/* push one entry to f2 and the rest to f1 */
*(int *)buf = i;
bl.append(buf, sizeof(buf));
auto& f = (i < 1 ? f2 : f1);
- r = f->push(bl, null_yield);
+ r = f->push(&dp, bl, null_yield);
ASSERT_EQ(0, r);
}
std::string marker;
std::vector<RCf::list_entry> result;
bool more = false;
- r = f1->list(num, std::nullopt, &result, &more, null_yield);
+ r = f1->list(&dp, num, std::nullopt, &result, &more, null_yield);
ASSERT_EQ(0, r);
ASSERT_EQ(true, more);
ASSERT_EQ(num, result.size());
auto& entry = result[num - 1];
marker = entry.marker;
- r = f1->trim(marker, false, null_yield);
+ r = f1->trim(&dp, marker, false, null_yield);
/* list what's left by fifo2 */
const auto left = max_entries - num;
- f2->list(left, marker, &result, &more, null_yield);
+ f2->list(&dp, left, marker, &result, &more, null_yield);
ASSERT_EQ(left, result.size());
ASSERT_EQ(false, more);
static constexpr auto max_entry_size = 128ull;
std::unique_ptr<RCf::FIFO> f;
- auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield, std::nullopt,
+ auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield, std::nullopt,
std::nullopt, false, max_part_size,
max_entry_size);
ASSERT_EQ(0, r);
}
ASSERT_EQ(max_entries, bufs.size());
- r = f->push(bufs, null_yield);
+ r = f->push(&dp, bufs, null_yield);
ASSERT_EQ(0, r);
/* list all */
std::vector<RCf::list_entry> result;
bool more = false;
- r = f->list(max_entries, std::nullopt, &result, &more, null_yield);
+ r = f->list(&dp, max_entries, std::nullopt, &result, &more, null_yield);
ASSERT_EQ(0, r);
ASSERT_EQ(false, more);
ASSERT_EQ(max_entries, result.size());
static constexpr auto max_part_size = 2048ull;
static constexpr auto max_entry_size = 128ull;
std::unique_ptr<RCf::FIFO> f;
- auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield, std::nullopt,
+ auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield, std::nullopt,
std::nullopt, false, max_part_size,
max_entry_size);
ASSERT_EQ(0, r);
}
ASSERT_EQ(max_entries, bufs.size());
- r = f->push(bufs, null_yield);
+ r = f->push(&dp, bufs, null_yield);
ASSERT_EQ(0, r);
auto info = f->meta();
/* list all at once */
std::vector<RCf::list_entry> result;
bool more = false;
- r = f->list(max_entries, std::nullopt, &result, &more, null_yield);
+ r = f->list(&dp, max_entries, std::nullopt, &result, &more, null_yield);
ASSERT_EQ(0, r);
ASSERT_EQ(false, more);
ASSERT_EQ(max_entries, result.size());
marker.reset();
for (auto i = 0u; i < max_entries; ++i) {
/* read single entry */
- r = f->list(1, marker, &result, &more, null_yield);
+ r = f->list(&dp, 1, marker, &result, &more, null_yield);
ASSERT_EQ(0, r);
ASSERT_EQ(result.size(), 1);
const bool expected_more = (i != (max_entries - 1));
marker = result.front().marker;
std::unique_ptr<R::AioCompletion> c(rados.aio_create_completion(nullptr,
nullptr));
- f->trim(*marker, false, c.get());
+ f->trim(&dp, *marker, false, c.get());
c->wait_for_complete();
r = c->get_return_value();
ASSERT_EQ(0, r);
ASSERT_EQ(info.tail_part_num, i / entries_per_part);
/* try to read all again, see how many entries left */
- r = f->list(max_entries, marker, &result, &more, null_yield);
+ r = f->list(&dp, max_entries, marker, &result, &more, null_yield);
ASSERT_EQ(max_entries - i - 1, result.size());
ASSERT_EQ(false, more);
}
RCf::part_info partinfo;
/* check old tails are removed */
for (auto i = 0; i < info.tail_part_num; ++i) {
- r = f->get_part_info(i, &partinfo, null_yield);
+ r = f->get_part_info(&dp, i, &partinfo, null_yield);
ASSERT_EQ(-ENOENT, r);
}
/* check current tail exists */
- r = f->get_part_info(info.tail_part_num, &partinfo, null_yield);
+ r = f->get_part_info(&dp, info.tail_part_num, &partinfo, null_yield);
ASSERT_EQ(0, r);
}
TEST_F(LegacyFIFO, TestTrimExclusive) {
std::unique_ptr<RCf::FIFO> f;
- auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield);
+ auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield);
ASSERT_EQ(0, r);
std::vector<RCf::list_entry> result;
bool more = false;
for (uint32_t i = 0; i < max_entries; ++i) {
cb::list bl;
encode(i, bl);
- f->push(bl, null_yield);
+ f->push(&dp, bl, null_yield);
}
- f->list(1, std::nullopt, &result, &more, null_yield);
+ f->list(&dp, 1, std::nullopt, &result, &more, null_yield);
auto [val, marker] = decode_entry<std::uint32_t>(result.front());
ASSERT_EQ(0, val);
- f->trim(marker, true, null_yield);
+ f->trim(&dp, marker, true, null_yield);
result.clear();
- f->list(max_entries, std::nullopt, &result, &more, null_yield);
+ f->list(&dp, max_entries, std::nullopt, &result, &more, null_yield);
std::tie(val, marker) = decode_entry<std::uint32_t>(result.front());
ASSERT_EQ(0, val);
- f->trim(result[4].marker, true, null_yield);
+ f->trim(&dp, result[4].marker, true, null_yield);
result.clear();
- f->list(max_entries, std::nullopt, &result, &more, null_yield);
+ f->list(&dp, max_entries, std::nullopt, &result, &more, null_yield);
std::tie(val, marker) = decode_entry<std::uint32_t>(result.front());
ASSERT_EQ(4, val);
- f->trim(result.back().marker, true, null_yield);
+ f->trim(&dp, result.back().marker, true, null_yield);
result.clear();
- f->list(max_entries, std::nullopt, &result, &more, null_yield);
+ f->list(&dp, max_entries, std::nullopt, &result, &more, null_yield);
std::tie(val, marker) = decode_entry<std::uint32_t>(result.front());
ASSERT_EQ(result.size(), 1);
ASSERT_EQ(max_entries - 1, val);
TEST_F(AioLegacyFIFO, TestPushListTrim)
{
std::unique_ptr<RCf::FIFO> f;
- auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield);
+ auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield);
ASSERT_EQ(0, r);
static constexpr auto max_entries = 10u;
for (uint32_t i = 0; i < max_entries; ++i) {
cb::list bl;
encode(i, bl);
auto c = R::Rados::aio_create_completion();
- f->push(bl, c);
+ f->push(&dp, bl, c);
c->wait_for_complete();
r = c->get_return_value();
c->release();
bool more = false;
for (auto i = 0u; i < max_entries; ++i) {
auto c = R::Rados::aio_create_completion();
- f->list(1, marker, &result, &more, c);
+ f->list(&dp, 1, marker, &result, &more, c);
c->wait_for_complete();
r = c->get_return_value();
c->release();
std::string markers[max_entries];
std::uint32_t min_entry = 0;
auto c = R::Rados::aio_create_completion();
- f->list(max_entries * 10, std::nullopt, &result, &more, c);
+ f->list(&dp, max_entries * 10, std::nullopt, &result, &more, c);
c->wait_for_complete();
r = c->get_return_value();
c->release();
/* trim one entry */
c = R::Rados::aio_create_completion();
- f->trim(markers[min_entry], false, c);
+ f->trim(&dp, markers[min_entry], false, c);
c->wait_for_complete();
r = c->get_return_value();
c->release();
++min_entry;
c = R::Rados::aio_create_completion();
- f->list(max_entries * 10, std::nullopt, &result, &more, c);
+ f->list(&dp, max_entries * 10, std::nullopt, &result, &more, c);
c->wait_for_complete();
r = c->get_return_value();
c->release();
static constexpr auto max_entry_size = 128ull;
std::unique_ptr<RCf::FIFO> f;
- auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield, std::nullopt,
+ auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield, std::nullopt,
std::nullopt, false, max_part_size, max_entry_size);
ASSERT_EQ(0, r);
bl.append(buf, sizeof(buf));
auto c = R::Rados::aio_create_completion();
- f->push(bl, c);
+ f->push(&dp, bl, c);
c->wait_for_complete();
r = c->get_return_value();
ASSERT_EQ(-E2BIG, r);
c->release();
c = R::Rados::aio_create_completion();
- f->push(std::vector<cb::list>{}, c);
+ f->push(&dp, std::vector<cb::list>{}, c);
c->wait_for_complete();
r = c->get_return_value();
c->release();
static constexpr auto max_part_size = 2048ull;
static constexpr auto max_entry_size = 128ull;
std::unique_ptr<RCf::FIFO> f;
- auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield, std::nullopt,
+ auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield, std::nullopt,
std::nullopt, false, max_part_size,
max_entry_size);
ASSERT_EQ(0, r);
{
auto c = R::Rados::aio_create_completion();
- f->get_head_info([&](int r, RCf::part_info&& p) {
+ f->get_head_info(&dp, [&](int r, RCf::part_info&& p) {
ASSERT_TRUE(p.tag.empty());
ASSERT_EQ(0, p.magic);
ASSERT_EQ(0, p.min_ofs);
*(int *)buf = i;
bl.append(buf, sizeof(buf));
auto c = R::Rados::aio_create_completion();
- f->push(bl, c);
+ f->push(&dp, bl, c);
c->wait_for_complete();
r = c->get_return_value();
c->release();
std::vector<RCf::list_entry> result;
bool more = false;
auto c = R::Rados::aio_create_completion();
- f->list(max_entries, std::nullopt, &result, &more, c);
+ f->list(&dp, max_entries, std::nullopt, &result, &more, c);
c->wait_for_complete();
r = c->get_return_value();
c->release();
for (auto i = 0u; i < max_entries; ++i) {
c = R::Rados::aio_create_completion();
- f->list(1, marker, &result, &more, c);
+ f->list(&dp, 1, marker, &result, &more, c);
c->wait_for_complete();
r = c->get_return_value();
c->release();
for (auto i = 0u; i < max_entries; ++i) {
/* read single entry */
c = R::Rados::aio_create_completion();
- f->list(1, marker, &result, &more, c);
+ f->list(&dp, 1, marker, &result, &more, c);
c->wait_for_complete();
r = c->get_return_value();
c->release();
marker = result.front().marker;
c = R::Rados::aio_create_completion();
- f->trim(*marker, false, c);
+ f->trim(&dp, *marker, false, c);
c->wait_for_complete();
r = c->get_return_value();
c->release();
/* try to read all again, see how many entries left */
c = R::Rados::aio_create_completion();
- f->list(max_entries, marker, &result, &more, c);
+ f->list(&dp, max_entries, marker, &result, &more, c);
c->wait_for_complete();
r = c->get_return_value();
c->release();
ASSERT_EQ(0, r);
c = R::Rados::aio_create_completion();
- f->get_head_info([&](int r, RCf::part_info&& p) {
+ f->get_head_info(&dp, [&](int r, RCf::part_info&& p) {
ASSERT_EQ(next_ofs, p.next_ofs);
}, c);
c->wait_for_complete();
static constexpr auto max_entry_size = 128ull;
std::unique_ptr<RCf::FIFO> f;
- auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield, std::nullopt,
+ auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield, std::nullopt,
std::nullopt, false, max_part_size,
max_entry_size);
ASSERT_EQ(0, r);
(max_entry_size + part_entry_overhead));
const auto max_entries = entries_per_part * 4 + 1;
std::unique_ptr<RCf::FIFO> f2;
- r = RCf::FIFO::open(ioctx, fifo_id, &f2, null_yield);
+ r = RCf::FIFO::open(&dp, ioctx, fifo_id, &f2, null_yield);
std::vector fifos{&f, &f2};
for (auto i = 0u; i < max_entries; ++i) {
bl.append(buf, sizeof(buf));
auto& f = *fifos[i % fifos.size()];
auto c = R::Rados::aio_create_completion();
- f->push(bl, c);
+ f->push(&dp, bl, c);
c->wait_for_complete();
r = c->get_return_value();
c->release();
std::vector<RCf::list_entry> result;
bool more = false;
auto c = R::Rados::aio_create_completion();
- f2->list(max_entries, std::nullopt, &result, &more, c);
+ f2->list(&dp, max_entries, std::nullopt, &result, &more, c);
c->wait_for_complete();
r = c->get_return_value();
c->release();
ASSERT_EQ(max_entries, result.size());
c = R::Rados::aio_create_completion();
- f2->list(max_entries, std::nullopt, &result, &more, c);
+ f2->list(&dp, max_entries, std::nullopt, &result, &more, c);
c->wait_for_complete();
r = c->get_return_value();
c->release();
static constexpr auto max_part_size = 2048ull;
static constexpr auto max_entry_size = 128ull;
std::unique_ptr<RCf::FIFO> f1;
- auto r = RCf::FIFO::create(ioctx, fifo_id, &f1, null_yield, std::nullopt,
+ auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f1, null_yield, std::nullopt,
std::nullopt, false, max_part_size,
max_entry_size);
ASSERT_EQ(0, r);
const auto max_entries = entries_per_part * 4 + 1;
std::unique_ptr<RCf::FIFO> f2;
- r = RCf::FIFO::open(ioctx, fifo_id, &f2, null_yield);
+ r = RCf::FIFO::open(&dp, ioctx, fifo_id, &f2, null_yield);
ASSERT_EQ(0, r);
/* push one entry to f2 and the rest to f1 */
bl.append(buf, sizeof(buf));
auto& f = (i < 1 ? f2 : f1);
auto c = R::Rados::aio_create_completion();
- f->push(bl, c);
+ f->push(&dp, bl, c);
c->wait_for_complete();
r = c->get_return_value();
c->release();
std::vector<RCf::list_entry> result;
bool more = false;
auto c = R::Rados::aio_create_completion();
- f1->list(num, std::nullopt, &result, &more, c);
+ f1->list(&dp, num, std::nullopt, &result, &more, c);
c->wait_for_complete();
r = c->get_return_value();
c->release();
auto& entry = result[num - 1];
marker = entry.marker;
c = R::Rados::aio_create_completion();
- f1->trim(marker, false, c);
+ f1->trim(&dp, marker, false, c);
c->wait_for_complete();
r = c->get_return_value();
c->release();
const auto left = max_entries - num;
c = R::Rados::aio_create_completion();
- f2->list(left, marker, &result, &more, c);
+ f2->list(&dp, left, marker, &result, &more, c);
c->wait_for_complete();
r = c->get_return_value();
c->release();
static constexpr auto max_entry_size = 128ull;
std::unique_ptr<RCf::FIFO> f;
- auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield, std::nullopt,
+ auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield, std::nullopt,
std::nullopt, false, max_part_size,
max_entry_size);
ASSERT_EQ(0, r);
ASSERT_EQ(max_entries, bufs.size());
auto c = R::Rados::aio_create_completion();
- f->push(bufs, c);
+ f->push(&dp, bufs, c);
c->wait_for_complete();
r = c->get_return_value();
c->release();
std::vector<RCf::list_entry> result;
bool more = false;
c = R::Rados::aio_create_completion();
- f->list(max_entries, std::nullopt, &result, &more, c);
+ f->list(&dp, max_entries, std::nullopt, &result, &more, c);
c->wait_for_complete();
r = c->get_return_value();
c->release();
TEST_F(LegacyFIFO, TrimAll)
{
std::unique_ptr<RCf::FIFO> f;
- auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield);
+ auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield);
ASSERT_EQ(0, r);
static constexpr auto max_entries = 10u;
for (uint32_t i = 0; i < max_entries; ++i) {
cb::list bl;
encode(i, bl);
- r = f->push(bl, null_yield);
+ r = f->push(&dp, bl, null_yield);
ASSERT_EQ(0, r);
}
/* trim one entry */
- r = f->trim(RCf::marker::max().to_string(), false, null_yield);
+ r = f->trim(&dp, RCf::marker::max().to_string(), false, null_yield);
ASSERT_EQ(-ENODATA, r);
std::vector<RCf::list_entry> result;
bool more;
- r = f->list(1, std::nullopt, &result, &more, null_yield);
+ r = f->list(&dp, 1, std::nullopt, &result, &more, null_yield);
ASSERT_EQ(0, r);
ASSERT_TRUE(result.empty());
}
TEST_F(LegacyFIFO, AioTrimAll)
{
std::unique_ptr<RCf::FIFO> f;
- auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield);
+ auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield);
ASSERT_EQ(0, r);
static constexpr auto max_entries = 10u;
for (uint32_t i = 0; i < max_entries; ++i) {
cb::list bl;
encode(i, bl);
- r = f->push(bl, null_yield);
+ r = f->push(&dp, bl, null_yield);
ASSERT_EQ(0, r);
}
auto c = R::Rados::aio_create_completion();
- f->trim(RCf::marker::max().to_string(), false, c);
+ f->trim(&dp, RCf::marker::max().to_string(), false, c);
c->wait_for_complete();
r = c->get_return_value();
c->release();
std::vector<RCf::list_entry> result;
bool more;
- r = f->list(1, std::nullopt, &result, &more, null_yield);
+ r = f->list(&dp, 1, std::nullopt, &result, &more, null_yield);
ASSERT_EQ(0, r);
ASSERT_TRUE(result.empty());
}