From a10c2150af2f13f56197e3b59b4fa218bfd361b3 Mon Sep 17 00:00:00 2001 From: "Adam C. Emerson" Date: Tue, 24 Jan 2023 03:12:21 -0500 Subject: [PATCH] cls/log: Switch from utime_t to ceph::real_time Signed-off-by: Adam C. Emerson --- src/cls/log/cls_log.cc | 21 ++++++----- src/cls/log/cls_log_client.cc | 17 +++++---- src/cls/log/cls_log_client.h | 19 ++++++---- src/cls/log/cls_log_ops.h | 24 +++++++----- src/cls/log/cls_log_types.h | 18 ++++----- src/rgw/driver/rados/rgw_datalog.cc | 8 ++-- src/rgw/driver/rados/rgw_metadata.cc | 2 +- src/rgw/driver/rados/rgw_sync.cc | 6 +-- src/rgw/driver/rados/rgw_sync.h | 2 +- src/rgw/rgw_metadata.cc | 3 +- src/rgw/services/svc_cls.cc | 15 ++------ src/test/cls_log/test_cls_log.cc | 55 ++++++++++++++-------------- src/test/rgw/test_log_backing.cc | 7 ++-- 13 files changed, 99 insertions(+), 98 deletions(-) diff --git a/src/cls/log/cls_log.cc b/src/cls/log/cls_log.cc index 58a8524da34..65b070756e7 100644 --- a/src/cls/log/cls_log.cc +++ b/src/cls/log/cls_log.cc @@ -2,7 +2,9 @@ // vim: ts=8 sw=2 smarttab #include "include/types.h" -#include "include/utime.h" + +#include "common/ceph_time.h" + #include "objclass/objclass.h" #include "cls_log_types.h" @@ -15,6 +17,7 @@ using std::map; using std::string; using ceph::bufferlist; +using namespace std::literals; CLS_VER(1,0) CLS_NAME(log) @@ -34,10 +37,11 @@ static int write_log_entry(cls_method_context_t hctx, string& index, cls_log_ent return 0; } -static void get_index_time_prefix(utime_t& ts, string& index) +static void get_index_time_prefix(ceph::real_time ts, string& index) { + auto tv = ceph::real_clock::to_timeval(ts); char buf[32]; - snprintf(buf, sizeof(buf), "%010ld.%06ld_", (long)ts.sec(), (long)ts.usec()); + snprintf(buf, sizeof(buf), "%010ld.%06ld_", (long)tv.tv_sec, (long)tv.tv_usec); index = log_index_prefix + buf; } @@ -77,7 +81,7 @@ static int write_header(cls_method_context_t hctx, cls_log_header& header) return 0; } -static void get_index(cls_method_context_t hctx, utime_t& ts, string& index) +static void get_index(cls_method_context_t hctx, ceph::real_time ts, string& index) { get_index_time_prefix(ts, index); @@ -111,7 +115,7 @@ static int cls_log_add(cls_method_context_t hctx, bufferlist *in, bufferlist *ou string index; - utime_t timestamp = entry.timestamp; + auto timestamp = entry.timestamp; if (op.monotonic_inc && timestamp < header.max_time) timestamp = header.max_time; else if (timestamp > header.max_time) @@ -164,12 +168,12 @@ static int cls_log_list(cls_method_context_t hctx, bufferlist *in, bufferlist *o } else { from_index = op.marker; } - bool use_time_boundary = (!op.from_time.is_zero() && (op.to_time >= op.from_time)); + bool use_time_boundary = (!ceph::real_clock::is_zero(op.from_time) && (op.to_time >= op.from_time)); if (use_time_boundary) get_index_time_prefix(op.to_time, to_index); -#define MAX_ENTRIES 1000 + static constexpr auto MAX_ENTRIES = 1000u; size_t max_entries = op.max_entries; if (!max_entries || max_entries > MAX_ENTRIES) max_entries = MAX_ENTRIES; @@ -236,8 +240,7 @@ static int cls_log_trim(cls_method_context_t hctx, bufferlist *in, bufferlist *o // cls_cxx_map_remove_range() expects one-past-end if (op.to_marker.empty()) { auto t = op.to_time; - t.nsec_ref() += 1000; // equivalent to usec() += 1 - t.normalize(); + t += 1000us; // equivalent to usec() += 1 get_index_time_prefix(t, to_index); } else { to_index = op.to_marker; diff --git a/src/cls/log/cls_log_client.cc b/src/cls/log/cls_log_client.cc index 18510b6b2fa..531cb765f72 100644 --- a/src/cls/log/cls_log_client.cc +++ b/src/cls/log/cls_log_client.cc @@ -34,8 +34,8 @@ void cls_log_add(librados::ObjectWriteOperation& op, cls_log_entry& entry) op.exec("log", "add", in); } -void cls_log_add_prepare_entry(cls_log_entry& entry, const utime_t& timestamp, - const string& section, const string& name, bufferlist& bl) +void cls_log_add_prepare_entry(cls_log_entry& entry, ceph::real_time timestamp, + const string& section, const string& name, bufferlist& bl) { entry.timestamp = timestamp; entry.section = section; @@ -43,7 +43,7 @@ void cls_log_add_prepare_entry(cls_log_entry& entry, const utime_t& timestamp, entry.data = bl; } -void cls_log_add(librados::ObjectWriteOperation& op, const utime_t& timestamp, +void cls_log_add(librados::ObjectWriteOperation& op, ceph::real_time timestamp, const string& section, const string& name, bufferlist& bl) { cls_log_entry entry; @@ -52,8 +52,8 @@ void cls_log_add(librados::ObjectWriteOperation& op, const utime_t& timestamp, cls_log_add(op, entry); } -void cls_log_trim(librados::ObjectWriteOperation& op, const utime_t& from_time, const utime_t& to_time, - const string& from_marker, const string& to_marker) +void cls_log_trim(librados::ObjectWriteOperation& op, ceph::real_time from_time, + ceph::real_time to_time, const string& from_marker, const string& to_marker) { bufferlist in; cls_log_trim_op call; @@ -65,7 +65,8 @@ void cls_log_trim(librados::ObjectWriteOperation& op, const utime_t& from_time, op.exec("log", "trim", in); } -int cls_log_trim(librados::IoCtx& io_ctx, const string& oid, const utime_t& from_time, const utime_t& to_time, +int cls_log_trim(librados::IoCtx& io_ctx, const string& oid, + ceph::real_time from_time, ceph::real_time to_time, const string& from_marker, const string& to_marker) { bool done = false; @@ -113,8 +114,8 @@ public: } }; -void cls_log_list(librados::ObjectReadOperation& op, const utime_t& from, - const utime_t& to, const string& in_marker, int max_entries, +void cls_log_list(librados::ObjectReadOperation& op, ceph::real_time from, + ceph::real_time to, const string& in_marker, int max_entries, vector& entries, string *out_marker, bool *truncated) { diff --git a/src/cls/log/cls_log_client.h b/src/cls/log/cls_log_client.h index 5187b557567..12cd88c2601 100644 --- a/src/cls/log/cls_log_client.h +++ b/src/cls/log/cls_log_client.h @@ -11,26 +11,29 @@ * log objclass */ -void cls_log_add_prepare_entry(cls_log_entry& entry, const utime_t& timestamp, - const std::string& section, const std::string& name, ceph::buffer::list& bl); +void cls_log_add_prepare_entry(cls_log_entry& entry, ceph::real_time timestamp, + const std::string& section, + const std::string& name, ceph::buffer::list& bl); void cls_log_add(librados::ObjectWriteOperation& op, std::vector& entries, bool monotonic_inc); void cls_log_add(librados::ObjectWriteOperation& op, cls_log_entry& entry); -void cls_log_add(librados::ObjectWriteOperation& op, const utime_t& timestamp, +void cls_log_add(librados::ObjectWriteOperation& op, ceph::real_time timestamp, const std::string& section, const std::string& name, ceph::buffer::list& bl); -void cls_log_list(librados::ObjectReadOperation& op, const utime_t& from, - const utime_t& to, const std::string& in_marker, +void cls_log_list(librados::ObjectReadOperation& op, ceph::real_time from, + ceph::real_time to, const std::string& in_marker, int max_entries, std::vector& entries, std::string *out_marker, bool *truncated); -void cls_log_trim(librados::ObjectWriteOperation& op, const utime_t& from_time, const utime_t& to_time, - const std::string& from_marker, const std::string& to_marker); +void cls_log_trim(librados::ObjectWriteOperation& op, ceph::real_time from_time, + ceph::real_time to_time, const std::string& from_marker, + const std::string& to_marker); // these overloads which call io_ctx.operate() should not be called in the rgw. // rgw_rados_operate() should be called after the overloads w/o calls to io_ctx.operate() #ifndef CLS_CLIENT_HIDE_IOCTX -int cls_log_trim(librados::IoCtx& io_ctx, const std::string& oid, const utime_t& from_time, const utime_t& to_time, +int cls_log_trim(librados::IoCtx& io_ctx, const std::string& oid, + ceph::real_time from_time, ceph::real_time to_time, const std::string& from_marker, const std::string& to_marker); #endif diff --git a/src/cls/log/cls_log_ops.h b/src/cls/log/cls_log_ops.h index 82207d52100..a1477ccc603 100644 --- a/src/cls/log/cls_log_ops.h +++ b/src/cls/log/cls_log_ops.h @@ -35,13 +35,14 @@ struct cls_log_add_op { } static void generate_test_instances(std::list& l) { + using namespace std::literals; l.push_back(new cls_log_add_op); l.push_back(new cls_log_add_op); l.back()->entries.push_back(cls_log_entry()); l.back()->entries.push_back(cls_log_entry()); l.back()->entries.back().section = "section"; l.back()->entries.back().name = "name"; - l.back()->entries.back().timestamp = utime_t(1, 2); + l.back()->entries.back().timestamp = ceph::real_time{1s + 2ns}; l.back()->entries.back().data.append("data"); l.back()->entries.back().id = "id"; } @@ -49,9 +50,9 @@ struct cls_log_add_op { WRITE_CLASS_ENCODER(cls_log_add_op) struct cls_log_list_op { - utime_t from_time; + ceph::real_time from_time; std::string marker; /* if not empty, overrides from_time */ - utime_t to_time; /* not inclusive */ + ceph::real_time to_time; /* not inclusive */ int max_entries; /* upperbound to returned num of entries might return less than that and still be truncated */ @@ -82,11 +83,12 @@ struct cls_log_list_op { f->dump_int("max_entries", max_entries); } static void generate_test_instances(std::list& ls) { + using namespace std::literals; ls.push_back(new cls_log_list_op); ls.push_back(new cls_log_list_op); - ls.back()->from_time = utime_t(1, 2); + ls.back()->from_time = ceph::real_time{1s + 2ns}; ls.back()->marker = "marker"; - ls.back()->to_time = utime_t(3, 4); + ls.back()->to_time = ceph::real_time{3s + 4ns}; ls.back()->max_entries = 5; } }; @@ -121,13 +123,14 @@ struct cls_log_list_ret { f->dump_bool("truncated", truncated); } static void generate_test_instances(std::list& ls) { + using namespace std::literals; ls.push_back(new cls_log_list_ret); ls.push_back(new cls_log_list_ret); ls.back()->entries.push_back(cls_log_entry()); ls.back()->entries.push_back(cls_log_entry()); ls.back()->entries.back().section = "section"; ls.back()->entries.back().name = "name"; - ls.back()->entries.back().timestamp = utime_t(1, 2); + ls.back()->entries.back().timestamp = ceph::real_time{1s + 2ns}; ls.back()->entries.back().data.append("data"); ls.back()->entries.back().id = "id"; ls.back()->marker = "marker"; @@ -142,8 +145,8 @@ WRITE_CLASS_ENCODER(cls_log_list_ret) * -ENODATA when done, so caller needs to repeat sending request until that. */ struct cls_log_trim_op { - utime_t from_time; - utime_t to_time; /* inclusive */ + ceph::real_time from_time; + ceph::real_time to_time; /* inclusive */ std::string from_marker; std::string to_marker; @@ -175,10 +178,11 @@ struct cls_log_trim_op { f->dump_string("to_marker", to_marker); } static void generate_test_instances(std::list& ls) { + using namespace std::literals; ls.push_back(new cls_log_trim_op); ls.push_back(new cls_log_trim_op); - ls.back()->from_time = utime_t(1, 2); - ls.back()->to_time = utime_t(3, 4); + ls.back()->from_time = ceph::real_time{1s + 2ns}; + ls.back()->to_time = ceph::real_time(3s + 4ns); ls.back()->from_marker = "from_marker"; ls.back()->to_marker = "to_marker"; } diff --git a/src/cls/log/cls_log_types.h b/src/cls/log/cls_log_types.h index c0be0513366..c96b56503f7 100644 --- a/src/cls/log/cls_log_types.h +++ b/src/cls/log/cls_log_types.h @@ -8,11 +8,12 @@ #include "include/buffer.h" #include "include/encoding.h" #include "include/types.h" -#include "include/utime.h" #include "common/ceph_json.h" #include "common/Formatter.h" +#include "common/ceph_time.h" + class JSONObj; class JSONDecoder; @@ -20,7 +21,7 @@ struct cls_log_entry { std::string id; std::string section; std::string name; - utime_t timestamp; + ceph::real_time timestamp; ceph::buffer::list data; cls_log_entry() = default; @@ -28,12 +29,7 @@ struct cls_log_entry { cls_log_entry(ceph::real_time timestamp, std::string section, std::string name, ceph::buffer::list&& data) : section(std::move(section)), name(std::move(name)), - timestamp(utime_t(timestamp)), data(std::move(data)) {} - - cls_log_entry(utime_t timestamp, std::string section, - std::string name, ceph::buffer::list&& data) - : section(std::move(section)), name(std::move(name)), timestamp(timestamp), - data(std::move(data)) {} + timestamp(timestamp), data(std::move(data)) {} void encode(ceph::buffer::list& bl) const { ENCODE_START(2, 1, bl); @@ -78,7 +74,7 @@ struct cls_log_entry { l.back()->id = "test_id"; l.back()->section = "test_section"; l.back()->name = "test_name"; - l.back()->timestamp = utime_t(); + l.back()->timestamp = ceph::real_time{}; ceph::buffer::list bl; ceph::encode(std::string("Test"), bl, 0); l.back()->data = bl; @@ -88,7 +84,7 @@ WRITE_CLASS_ENCODER(cls_log_entry) struct cls_log_header { std::string max_marker; - utime_t max_time; + ceph::real_time max_time; void encode(ceph::buffer::list& bl) const { ENCODE_START(1, 1, bl); @@ -111,7 +107,7 @@ struct cls_log_header { o.push_back(new cls_log_header); o.push_back(new cls_log_header); o.back()->max_marker = "test_marker"; - o.back()->max_time = utime_t(); + o.back()->max_time = ceph::real_clock::zero(); } }; inline bool operator ==(const cls_log_header& lhs, const cls_log_header& rhs) { diff --git a/src/rgw/driver/rados/rgw_datalog.cc b/src/rgw/driver/rados/rgw_datalog.cc index 99b3fedab44..7988fc122d9 100644 --- a/src/rgw/driver/rados/rgw_datalog.cc +++ b/src/rgw/driver/rados/rgw_datalog.cc @@ -123,7 +123,7 @@ public: } cls_log_entry e; - cls_log_add_prepare_entry(e, utime_t(ut), {}, key, entry); + cls_log_add_prepare_entry(e, ut, {}, key, entry); std::get(out).push_back(std::move(e)); } int push(const DoutPrefixProvider *dpp, int index, entries&& items, optional_yield y) override { @@ -141,7 +141,7 @@ public: const std::string& key, ceph::buffer::list&& bl, optional_yield y) override { lr::ObjectWriteOperation op; - cls_log_add(op, utime_t(now), {}, key, bl); + cls_log_add(op, now, {}, key, bl); auto r = rgw_rados_operate(dpp, ioctx, oids[index], std::move(op), y); if (r < 0) { ldpp_dout(dpp, -1) << __PRETTY_FUNCTION__ @@ -173,7 +173,7 @@ public: for (auto iter = log_entries.begin(); iter != log_entries.end(); ++iter) { rgw_data_change_log_entry log_entry; log_entry.log_id = iter->id; - auto rt = iter->timestamp.to_real_time(); + auto rt = iter->timestamp; log_entry.log_timestamp = rt; auto liter = iter->data.cbegin(); try { @@ -201,7 +201,7 @@ public: << cpp_strerror(-r) << dendl; } else { info->marker = header.max_marker; - info->last_update = header.max_time.to_real_time(); + info->last_update = header.max_time; } return r; } diff --git a/src/rgw/driver/rados/rgw_metadata.cc b/src/rgw/driver/rados/rgw_metadata.cc index 8878ae6c7c6..988087ca97a 100644 --- a/src/rgw/driver/rados/rgw_metadata.cc +++ b/src/rgw/driver/rados/rgw_metadata.cc @@ -137,7 +137,7 @@ int RGWMetadataLog::get_info(const DoutPrefixProvider *dpp, int shard_id, RGWMet return ret; info->marker = header.max_marker; - info->last_update = header.max_time.to_real_time(); + info->last_update = header.max_time; return 0; } diff --git a/src/rgw/driver/rados/rgw_sync.cc b/src/rgw/driver/rados/rgw_sync.cc index 3546bbe6bc3..a2e5446b1ab 100644 --- a/src/rgw/driver/rados/rgw_sync.cc +++ b/src/rgw/driver/rados/rgw_sync.cc @@ -1877,7 +1877,7 @@ public: continue; } tn->log(20, SSTR("log_entry: " << log_iter->id << ":" << log_iter->section << ":" << log_iter->name << ":" << log_iter->timestamp)); - if (!marker_tracker->start(log_iter->id, 0, log_iter->timestamp.to_real_time())) { + if (!marker_tracker->start(log_iter->id, 0, log_iter->timestamp)) { ldpp_dout(sync_env->dpp, 0) << "ERROR: cannot start syncing " << log_iter->id << ". Duplicate entry?" << dendl; } else { raw_key = log_iter->section + ":" + log_iter->name; @@ -2484,7 +2484,7 @@ int RGWCloneMetaLogCoroutine::state_read_shard_status() } } else { shard_info.marker = header.max_marker; - shard_info.last_update = header.max_time.to_real_time(); + shard_info.last_update = header.max_time; } // wake up parent stack io_complete(); @@ -2594,7 +2594,7 @@ int RGWCloneMetaLogCoroutine::state_store_mdlog_entries() dest_entry.id = entry.id; dest_entry.section = entry.section; dest_entry.name = entry.name; - dest_entry.timestamp = utime_t(entry.timestamp); + dest_entry.timestamp = entry.timestamp; encode(entry.log_data, dest_entry.data); diff --git a/src/rgw/driver/rados/rgw_sync.h b/src/rgw/driver/rados/rgw_sync.h index f0ee28056af..e7d482abac8 100644 --- a/src/rgw/driver/rados/rgw_sync.h +++ b/src/rgw/driver/rados/rgw_sync.h @@ -44,7 +44,7 @@ struct rgw_mdlog_entry { id = le.id; section = le.section; name = le.name; - timestamp = le.timestamp.to_real_time(); + timestamp = le.timestamp; try { auto iter = le.data.cbegin(); decode(log_data, iter); diff --git a/src/rgw/rgw_metadata.cc b/src/rgw/rgw_metadata.cc index 92b03e41bcd..fe1bc71d820 100644 --- a/src/rgw/rgw_metadata.cc +++ b/src/rgw/rgw_metadata.cc @@ -465,7 +465,8 @@ void RGWMetadataManager::dump_log_entry(cls_log_entry& entry, Formatter *f) f->dump_string("id", entry.id); f->dump_string("section", entry.section); f->dump_string("name", entry.name); - entry.timestamp.gmtime_nsec(f->dump_stream("timestamp")); + utime_t ts(entry.timestamp); + ts.gmtime_nsec(f->dump_stream("timestamp")); try { RGWMetadataLogData log_data; diff --git a/src/rgw/services/svc_cls.cc b/src/rgw/services/svc_cls.cc index de4d9531557..76ff34bc831 100644 --- a/src/rgw/services/svc_cls.cc +++ b/src/rgw/services/svc_cls.cc @@ -250,7 +250,7 @@ void RGWSI_Cls::TimeLog::prepare_entry(cls_log_entry& entry, const string& key, bufferlist& bl) { - cls_log_add_prepare_entry(entry, utime_t(ut), section, key, bl); + cls_log_add_prepare_entry(entry, ut, section, key, bl); } int RGWSI_Cls::TimeLog::init_obj(const DoutPrefixProvider *dpp, const string& oid, rgw_rados_ref& obj) @@ -274,8 +274,7 @@ int RGWSI_Cls::TimeLog::add(const DoutPrefixProvider *dpp, } librados::ObjectWriteOperation op; - utime_t t(ut); - cls_log_add(op, t, section, key, bl); + cls_log_add(op, ut, section, key, bl); return obj.operate(dpp, std::move(op), y); } @@ -324,10 +323,7 @@ int RGWSI_Cls::TimeLog::list(const DoutPrefixProvider *dpp, librados::ObjectReadOperation op; - utime_t st(start_time); - utime_t et(end_time); - - cls_log_list(op, st, et, marker, max_entries, entries, + cls_log_list(op, start_time, end_time, marker, max_entries, entries, out_marker, truncated); bufferlist obl; @@ -402,11 +398,8 @@ int RGWSI_Cls::TimeLog::trim(const DoutPrefixProvider *dpp, return r; } - utime_t st(start_time); - utime_t et(end_time); - librados::ObjectWriteOperation op; - cls_log_trim(op, st, et, from_marker, to_marker); + cls_log_trim(op, start_time, end_time, from_marker, to_marker); if (!completion) { r = obj.operate(dpp, std::move(op), y); diff --git a/src/test/cls_log/test_cls_log.cc b/src/test/cls_log/test_cls_log.cc index fdb4b784900..e725bc87c2a 100644 --- a/src/test/cls_log/test_cls_log.cc +++ b/src/test/cls_log/test_cls_log.cc @@ -5,8 +5,7 @@ #include "cls/log/cls_log_types.h" #include "cls/log/cls_log_client.h" -#include "include/utime.h" -#include "common/Clock.h" +#include "common/ceph_time.h" #include "global/global_context.h" #include "gtest/gtest.h" @@ -17,6 +16,10 @@ #include using namespace std; +using namespace std::literals; + +using ceph::real_time; +using ceph::real_clock; /// creates a temporary pool and initializes an IoCtx for each test class cls_log : public ::testing::Test { @@ -52,7 +55,7 @@ static int read_bl(bufferlist& bl, int *i) return 0; } -void add_log(librados::ObjectWriteOperation *op, utime_t& timestamp, string& section, string&name, int i) +void add_log(librados::ObjectWriteOperation *op, real_time timestamp, string& section, string&name, int i) { bufferlist bl; encode(i, bl); @@ -70,7 +73,7 @@ string get_name(int i) return name_prefix + buf; } -void generate_log(librados::IoCtx& ioctx, string& oid, int max, utime_t& start_time, bool modify_time) +void generate_log(librados::IoCtx& ioctx, string& oid, int max, real_time start_time, bool modify_time) { string section = "global"; @@ -80,11 +83,10 @@ void generate_log(librados::IoCtx& ioctx, string& oid, int max, utime_t& start_t for (i = 0; i < max; i++) { // coverity[store_truncates_time_t:SUPPRESS] - uint32_t secs = start_time.sec(); + auto ts = start_time; if (modify_time) - secs += i; + ts += i * 1s; - utime_t ts(secs, start_time.nsec()); string name = get_name(i); add_log(&op, ts, section, name, i); @@ -93,20 +95,17 @@ void generate_log(librados::IoCtx& ioctx, string& oid, int max, utime_t& start_t ASSERT_EQ(0, ioctx.operate(oid, &op)); } -utime_t get_time(utime_t& start_time, int i, bool modify_time) +real_time get_time(real_time start_time, int i, bool modify_time) { // coverity[store_truncates_time_t:SUPPRESS] - uint32_t secs = start_time.sec(); - if (modify_time) - secs += i; - return utime_t(secs, start_time.nsec()); + return modify_time ? start_time + (i * 1s) : start_time; } -void check_entry(cls_log_entry& entry, utime_t& start_time, int i, bool modified_time) +void check_entry(cls_log_entry& entry, real_time start_time, int i, bool modified_time) { string section = "global"; string name = get_name(i); - utime_t ts = get_time(start_time, i, modified_time); + auto ts = get_time(start_time, i, modified_time); ASSERT_EQ(section, entry.section); ASSERT_EQ(name, entry.name); @@ -114,7 +113,7 @@ void check_entry(cls_log_entry& entry, utime_t& start_time, int i, bool modified } static int log_list(librados::IoCtx& ioctx, const std::string& oid, - utime_t& from, utime_t& to, + real_time from, real_time to, const string& in_marker, int max_entries, vector& entries, string *out_marker, bool *truncated) @@ -127,7 +126,7 @@ static int log_list(librados::IoCtx& ioctx, const std::string& oid, } static int log_list(librados::IoCtx& ioctx, const std::string& oid, - utime_t& from, utime_t& to, int max_entries, + real_time from, real_time to, int max_entries, vector& entries, bool *truncated) { std::string marker; @@ -138,7 +137,7 @@ static int log_list(librados::IoCtx& ioctx, const std::string& oid, static int log_list(librados::IoCtx& ioctx, const std::string& oid, vector& entries) { - utime_t from, to; + real_time from, to; bool truncated{false}; return log_list(ioctx, oid, from, to, 0, entries, &truncated); } @@ -152,8 +151,8 @@ TEST_F(cls_log, test_log_add_same_time) ASSERT_EQ(0, ioctx.create(oid, true)); /* generate log */ - utime_t start_time = ceph_clock_now(); - utime_t to_time = get_time(start_time, 1, true); + auto start_time = real_clock::now(); + auto to_time = get_time(start_time, 1, true); generate_log(ioctx, oid, 10, start_time, false); vector entries; @@ -213,13 +212,13 @@ TEST_F(cls_log, test_log_add_different_time) ASSERT_EQ(0, ioctx.create(oid, true)); /* generate log */ - utime_t start_time = ceph_clock_now(); + auto start_time = real_clock::now(); generate_log(ioctx, oid, 10, start_time, true); vector entries; bool truncated; - utime_t to_time = utime_t(start_time.sec() + 10, start_time.nsec()); + auto to_time = start_time + (10 * 1s); { /* check list */ @@ -250,7 +249,7 @@ TEST_F(cls_log, test_log_add_different_time) /* check list again with shifted time */ { - utime_t next_time = get_time(start_time, 1, true); + auto next_time = get_time(start_time, 1, true); ASSERT_EQ(0, log_list(ioctx, oid, next_time, to_time, 0, entries, &truncated)); ASSERT_EQ(9u, entries.size()); @@ -282,7 +281,7 @@ int do_log_trim(librados::IoCtx& ioctx, const std::string& oid, } int do_log_trim(librados::IoCtx& ioctx, const std::string& oid, - const utime_t& from_time, const utime_t& to_time) + real_time from_time, real_time to_time) { librados::ObjectWriteOperation op; cls_log_trim(op, from_time, to_time, "", ""); @@ -298,7 +297,7 @@ TEST_F(cls_log, trim_by_time) ASSERT_EQ(0, ioctx.create(oid, true)); /* generate log */ - utime_t start_time = ceph_clock_now(); + auto start_time = real_clock::now(); generate_log(ioctx, oid, 10, start_time, true); vector entries; @@ -307,12 +306,12 @@ TEST_F(cls_log, trim_by_time) /* check list */ /* trim */ - utime_t to_time = get_time(start_time, 10, true); + auto to_time = get_time(start_time, 10, true); for (int i = 0; i < 10; i++) { - utime_t trim_time = get_time(start_time, i, true); + auto trim_time = get_time(start_time, i, true); - utime_t zero_time; + real_time zero_time; ASSERT_EQ(0, do_log_trim(ioctx, oid, zero_time, trim_time)); ASSERT_EQ(-ENODATA, do_log_trim(ioctx, oid, zero_time, trim_time)); @@ -329,7 +328,7 @@ TEST_F(cls_log, trim_by_marker) string oid = "obj"; ASSERT_EQ(0, ioctx.create(oid, true)); - utime_t start_time = ceph_clock_now(); + auto start_time = real_clock::now(); generate_log(ioctx, oid, 10, start_time, true); std::vector log1; diff --git a/src/test/rgw/test_log_backing.cc b/src/test/rgw/test_log_backing.cc index 248617e30bc..79e90f83a50 100644 --- a/src/test/rgw/test_log_backing.cc +++ b/src/test/rgw/test_log_backing.cc @@ -73,8 +73,9 @@ protected: lr::ObjectWriteOperation op; cb::list bl; encode(i, bl); - cls_log_add(op, ceph_clock_now(), {}, "meow", bl); - auto r = rgw_rados_operate(&dp, ioctx, get_oid(0, i), std::move(op), null_yield); + cls_log_add(op, ceph::real_clock::now(), {}, "meow", bl); + auto r = rgw_rados_operate(&dp, ioctx, get_oid(0, i), std::move(op), + null_yield); ASSERT_GE(r, 0); } } @@ -84,7 +85,7 @@ protected: lr::ObjectWriteOperation op; cb::list bl; encode(i, bl); - cls_log_add(op, ceph_clock_now(), {}, "meow", bl); + cls_log_add(op, ceph::real_clock::now(), {}, "meow", bl); auto r = rgw_rados_operate(&dp, ioctx, get_oid(0, i), std::move(op), null_yield); ASSERT_GE(r, 0); } -- 2.39.5