Skip to content

Commit 54eda98

Browse files
ronen-frronen-fr
authored
Merge pull request ceph#62498 from ronen-fr/wip-rf-with-array
common/Formatter: introduce helpers for formatting container types Reviewed-by: Alex Ainscow <[email protected]> Reviewed-by: Kefu Chai <[email protected]>
2 parents fa37364 + e2733f3 commit 54eda98

File tree

3 files changed

+187
-77
lines changed

3 files changed

+187
-77
lines changed

‎src/common/Formatter.h‎

Lines changed: 117 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,7 @@
77

88
#include <deque>
99
#include <fstream>
10+
#include <functional>
1011
#include <list>
1112
#include <memory>
1213
#include <vector>
@@ -54,6 +55,122 @@ namespace ceph {
5455
}
5556
};
5657

58+
/// Helper to check if a type is a map for our purpose
59+
/// (based on fmt code)
60+
template <typename T> class is_map {
61+
template <typename U> static auto check(U*) -> typename U::mapped_type;
62+
template <typename> static void check(...);
63+
public:
64+
static constexpr const bool value =
65+
!std::is_void<decltype(check<T>(nullptr))>::value;
66+
};
67+
68+
/**
69+
* with_array_section()
70+
* Opens an array section and calls 'fn' on each element in the container.
71+
* Two overloads are provided:
72+
* 1. for maps, where the function takes a key and a value, and
73+
* 2. for other types of containers, where the function takes just an
74+
* element.
75+
*/
76+
77+
// for maps
78+
template <
79+
typename M, //!< a map<K, V>
80+
typename FN, //!< a callable to be applied to each element
81+
typename K = std::remove_cvref_t<M>::key_type,
82+
typename V = std::remove_cvref_t<M>::mapped_type>
83+
requires(
84+
is_map<M>::value && (
85+
std::is_invocable_v<FN, Formatter&, const K&, const V&, std::string_view> ||
86+
std::is_invocable_v<FN, Formatter&, const K&, const V&>))
87+
void with_array_section(std::string_view txt, const M& m, FN&& fn) {
88+
Formatter::ArraySection as(*this, txt);
89+
for (const auto& [k, v] : m) {
90+
if constexpr (std::is_invocable_v<FN, Formatter&, const K&, const V&, std::string_view>) {
91+
std::invoke(std::forward<FN>(fn), *this, k, v, txt);
92+
} else {
93+
std::invoke(std::forward<FN>(fn), *this, k, v);
94+
}
95+
}
96+
}
97+
98+
// for other types of containers
99+
template <
100+
typename M,
101+
typename FN,
102+
typename V = std::remove_cvref_t<M>::value_type>
103+
requires(
104+
!is_map<M>::value && (
105+
std::is_invocable_r_v<void, FN, Formatter&, const V&,
106+
std::string_view> ||
107+
std::is_invocable_r_v<void, FN, Formatter&, const V&>))
108+
void with_array_section(std::string_view txt, const M& m, FN&& fn) {
109+
Formatter::ArraySection as(*this, txt);
110+
for (const auto& v : m) {
111+
if constexpr (std::is_invocable_v<
112+
FN, Formatter&, const V&, std::string_view>) {
113+
std::invoke(std::forward<FN>(fn), *this, v, txt);
114+
} else {
115+
std::invoke(std::forward<FN>(fn), *this, v);
116+
}
117+
}
118+
}
119+
120+
/**
121+
* with_obj_array_section()
122+
* Opens an array section, then - iterates over the container
123+
* (which can be a map or a vector) and creates an object section
124+
* for each element in the container. The provided function 'fn' is
125+
* called on each element in the container.
126+
*
127+
* Two overloads are provided:
128+
* 1. for maps, where the function takes a key and a value, and
129+
* 2. for other types of containers, where the function is only
130+
* handed the object (value) in the container.
131+
*/
132+
133+
template <
134+
typename M, //!< a map<K, V>
135+
typename FN, //!< a callable to be applied to each element
136+
typename K = std::remove_cvref_t<M>::key_type,
137+
typename V = std::remove_cvref_t<M>::mapped_type>
138+
requires(
139+
is_map<M>::value && (
140+
std::is_invocable_v<FN, Formatter&, const K&, const V&, std::string_view> ||
141+
std::is_invocable_v<FN, Formatter&, const K&, const V&>))
142+
void with_obj_array_section(std::string_view txt, const M& m, FN&& fn) {
143+
Formatter::ArraySection as(*this, txt);
144+
for (const auto& [k, v] : m) {
145+
Formatter::ObjectSection os(*this, txt);
146+
if constexpr (std::is_invocable_v<FN, Formatter&, const K&, const V&, std::string_view>) {
147+
std::invoke(std::forward<FN>(fn), *this, k, v, txt);
148+
} else {
149+
std::invoke(std::forward<FN>(fn), *this, k, v);
150+
}
151+
}
152+
}
153+
154+
template <
155+
typename M, //!< a container (which is not a map) of 'V's
156+
typename FN,
157+
typename V = std::remove_cvref_t<M>::value_type>
158+
requires(
159+
(!is_map<M>::value) && (
160+
std::is_invocable_v<FN, Formatter&, const V&, std::string_view> ||
161+
std::is_invocable_v<FN, Formatter&, const V&>))
162+
void with_obj_array_section(std::string_view txt, const M& m, FN&& fn) {
163+
Formatter::ArraySection as(*this, txt);
164+
for (const auto& v : m) {
165+
Formatter::ObjectSection os(*this, txt);
166+
if constexpr (std::is_invocable_v<FN, Formatter&, const V&, std::string_view>) {
167+
std::invoke(std::forward<FN>(fn), *this, v, txt);
168+
} else {
169+
std::invoke(std::forward<FN>(fn), *this, v);
170+
}
171+
}
172+
}
173+
57174
static Formatter *create(std::string_view type,
58175
std::string_view default_type,
59176
std::string_view fallback);

‎src/osd/ECMsgTypes.cc‎

Lines changed: 63 additions & 64 deletions
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,8 @@ using std::set;
2222
using ceph::bufferlist;
2323
using ceph::Formatter;
2424

25+
using namespace std::literals;
26+
2527
void ECSubWrite::encode(bufferlist &bl) const
2628
{
2729
ENCODE_START(4, 1, bl);
@@ -242,32 +244,28 @@ std::ostream &operator<<(
242244

243245
void ECSubRead::dump(Formatter *f) const
244246
{
247+
using extent_t = boost::tuple<uint64_t, uint64_t, uint32_t>;
248+
245249
f->dump_stream("from") << from;
246250
f->dump_unsigned("tid", tid);
247-
f->open_array_section("objects");
248-
for (auto i = to_read.cbegin(); i != to_read.cend(); ++i) {
249-
f->open_object_section("object");
250-
f->dump_stream("oid") << i->first;
251-
f->open_array_section("extents");
252-
for (auto j = i->second.cbegin(); j != i->second.cend(); ++j) {
253-
f->open_object_section("extent");
254-
f->dump_unsigned("off", j->get<0>());
255-
f->dump_unsigned("len", j->get<1>());
256-
f->dump_unsigned("flags", j->get<2>());
257-
f->close_section();
258-
}
259-
f->close_section();
260-
f->close_section();
261-
}
262-
f->close_section();
263251

264-
f->open_array_section("object_attrs_requested");
265-
for (auto i = attrs_to_read.cbegin(); i != attrs_to_read.cend(); ++i) {
266-
f->open_object_section("object");
267-
f->dump_stream("oid") << *i;
268-
f->close_section();
269-
}
270-
f->close_section();
252+
// 'to_read' (map<hobject_t, list<tuple<offset, length, flags>>>)
253+
f->with_obj_array_section(
254+
"object"sv, to_read,
255+
[](Formatter& f, const hobject_t& oid, const list<extent_t>& extents) {
256+
f.dump_stream("oid") << oid;
257+
f.with_obj_array_section(
258+
"extent", extents, [](Formatter& f, const extent_t& extent) {
259+
f.dump_unsigned("off", extent.get<0>());
260+
f.dump_unsigned("len", extent.get<1>());
261+
f.dump_unsigned("flags", extent.get<2>());
262+
});
263+
});
264+
265+
// 'object_attrs_requested': 'attrs_to_read' (set<hobject_t>)
266+
f->with_obj_array_section(
267+
"object_attrs_requested"sv, attrs_to_read,
268+
[](Formatter& f, const hobject_t& oid) { f.dump_stream("oid") << oid; });
271269
}
272270

273271
void ECSubRead::generate_test_instances(list<ECSubRead*>& o)
@@ -321,50 +319,51 @@ std::ostream &operator<<(
321319
<< ")";
322320
}
323321

324-
void ECSubReadReply::dump(Formatter *f) const
322+
323+
void ECSubReadReply::dump(Formatter* f) const
325324
{
325+
using offset_pair_t = pair<uint64_t, bufferlist>;
326+
using extents_list_t = list<offset_pair_t>;
327+
326328
f->dump_stream("from") << from;
327329
f->dump_unsigned("tid", tid);
328-
f->open_array_section("buffers_read");
329-
for (auto i = buffers_read.cbegin(); i != buffers_read.cend(); ++i) {
330-
f->open_object_section("object");
331-
f->dump_stream("oid") << i->first;
332-
f->open_array_section("data");
333-
for (auto j = i->second.cbegin(); j != i->second.cend(); ++j) {
334-
f->open_object_section("extent");
335-
f->dump_unsigned("off", j->first);
336-
f->dump_unsigned("buf_len", j->second.length());
337-
f->close_section();
338-
}
339-
f->close_section();
340-
f->close_section();
341-
}
342-
f->close_section();
343-
344-
f->open_array_section("attrs_returned");
345-
for (auto i = attrs_read.cbegin(); i != attrs_read.cend(); ++i) {
346-
f->open_object_section("object_attrs");
347-
f->dump_stream("oid") << i->first;
348-
f->open_array_section("attrs");
349-
for (auto j = i->second.cbegin(); j != i->second.cend(); ++j) {
350-
f->open_object_section("attr");
351-
f->dump_string("attr", j->first);
352-
f->dump_unsigned("val_len", j->second.length());
353-
f->close_section();
354-
}
355-
f->close_section();
356-
f->close_section();
357-
}
358-
f->close_section();
359-
360-
f->open_array_section("errors");
361-
for (auto i = errors.cbegin(); i != errors.cend(); ++i) {
362-
f->open_object_section("error_pair");
363-
f->dump_stream("oid") << i->first;
364-
f->dump_int("error", i->second);
365-
f->close_section();
366-
}
367-
f->close_section();
330+
331+
// 'buffers_read' (map<hobject_t, list<pair<uint64_t, bufferlist>>>)
332+
f->with_obj_array_section(
333+
"object"sv, buffers_read,
334+
[](Formatter& f, const hobject_t& oid, const extents_list_t& l) {
335+
f.dump_stream("oid") << oid;
336+
f.with_obj_array_section(
337+
"extent", l,
338+
[](Formatter& f, const offset_pair_t& offset_n_bl) {
339+
const auto& [off, bl] = offset_n_bl;
340+
f.dump_unsigned("off", off);
341+
f.dump_unsigned("buf_len", bl.length());
342+
});
343+
});
344+
345+
// "attrs_returned" (mapping hobject_t to a <string to bl> table)
346+
f->with_obj_array_section(
347+
"object_attrs"sv, attrs_read,
348+
[](Formatter& f, const hobject_t& oid,
349+
const std::map<std::string, ceph::buffer::list, std::less<>>& m) {
350+
f.dump_stream("oid") << oid;
351+
f.with_obj_array_section(
352+
"attr", m,
353+
[](Formatter& f, const std::string& attr,
354+
const ceph::buffer::list& bl) {
355+
f.dump_string("attr", attr);
356+
f.dump_unsigned("val_len", bl.length());
357+
});
358+
});
359+
360+
// "errors": map<hobject_t, int>
361+
f->with_obj_array_section(
362+
"error_pair"sv, errors,
363+
[](Formatter& f, const hobject_t& oid, int err) {
364+
f.dump_stream("oid") << oid;
365+
f.dump_int("error", err);
366+
});
368367
}
369368

370369
void ECSubReadReply::generate_test_instances(list<ECSubReadReply*>& o)

‎src/osd/scrubber/pg_scrubber.cc‎

Lines changed: 7 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -2342,12 +2342,10 @@ void PgScrubber::dump_active_scrubber(ceph::Formatter* f) const
23422342
f->dump_int("shallow_errors", m_shallow_errors);
23432343
f->dump_int("deep_errors", m_deep_errors);
23442344
f->dump_int("fixed", m_fixed_count);
2345-
{
2346-
Formatter::ArraySection waiting_on_whom{*f, "waiting_on_whom"sv};
2347-
for (const auto& p : m_maps_status.get_awaited()) {
2348-
f->dump_stream("shard") << p;
2349-
}
2350-
}
2345+
f->with_array_section(
2346+
"waiting_on_whom"sv, m_maps_status.get_awaited(),
2347+
[](Formatter& f, const pg_shard_t& sh) { f.dump_stream("shard") << sh; });
2348+
23512349
if (m_scrub_job->blocked) {
23522350
f->dump_string("schedule", "blocked");
23532351
} else {
@@ -2480,13 +2478,9 @@ void PgScrubber::handle_query_state(ceph::Formatter* f)
24802478
f->dump_stream("scrubber.max_end") << m_max_end;
24812479
f->dump_stream("scrubber.subset_last_update") << m_subset_last_update;
24822480
f->dump_bool("scrubber.deep", m_is_deep);
2483-
{
2484-
Formatter::ArraySection waiting_on_whom{*f, "waiting_on_whom"sv};
2485-
for (const auto& p : m_maps_status.get_awaited()) {
2486-
f->dump_stream("shard") << p;
2487-
}
2488-
}
2489-
2481+
f->with_array_section(
2482+
"waiting_on_whom"sv, m_maps_status.get_awaited(),
2483+
[](Formatter& f, const pg_shard_t& sh) { f.dump_stream("shard") << sh; });
24902484
f->dump_string("comment", "DEPRECATED - may be removed in the next release");
24912485
}
24922486

0 commit comments

Comments
 (0)