From 815879924f27827d7b477102cb5eb0163edf2948 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 | 11 +++--- src/cls/log/cls_log_types.h | 16 +++----- 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 | 56 ++++++++++++++-------------- src/test/rgw/test_log_backing.cc | 4 +- 13 files changed, 88 insertions(+), 92 deletions(-) diff --git a/src/cls/log/cls_log.cc b/src/cls/log/cls_log.cc index 58a8524da3412..65b070756e712 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 18510b6b2fabf..531cb765f7280 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 5187b55756786..12cd88c260170 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 50e0d743dc5c0..6d0c687e996a3 100644 --- a/src/cls/log/cls_log_ops.h +++ b/src/cls/log/cls_log_ops.h @@ -34,13 +34,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"; } @@ -48,9 +49,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 */ @@ -107,8 +108,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; diff --git a/src/cls/log/cls_log_types.h b/src/cls/log/cls_log_types.h index 7b00fe501568f..f137dbbfca6d3 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); diff --git a/src/rgw/driver/rados/rgw_datalog.cc b/src/rgw/driver/rados/rgw_datalog.cc index 403239077d284..ea2a3548ad45a 100644 --- a/src/rgw/driver/rados/rgw_datalog.cc +++ b/src/rgw/driver/rados/rgw_datalog.cc @@ -122,7 +122,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 { @@ -140,7 +140,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], &op, y); if (r < 0) { ldpp_dout(dpp, -1) << __PRETTY_FUNCTION__ @@ -172,7 +172,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 { @@ -200,7 +200,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 8878ae6c7c646..988087ca97a93 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 8b5768c86b68a..182b81655659e 100644 --- a/src/rgw/driver/rados/rgw_sync.cc +++ b/src/rgw/driver/rados/rgw_sync.cc @@ -1841,7 +1841,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; @@ -2434,7 +2434,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(); @@ -2540,7 +2540,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 f0ee28056afa7..e7d482abac81f 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 a6d75de0eba12..d1f1a32d4fd69 100644 --- a/src/rgw/rgw_metadata.cc +++ b/src/rgw/rgw_metadata.cc @@ -670,7 +670,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 7ebc0e409118d..c076f72cab475 100644 --- a/src/rgw/services/svc_cls.cc +++ b/src/rgw/services/svc_cls.cc @@ -262,7 +262,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, RGWSI_RADOS::Obj& obj) @@ -288,8 +288,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, &op, y); } @@ -338,10 +337,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; @@ -416,11 +412,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, &op, y); diff --git a/src/test/cls_log/test_cls_log.cc b/src/test/cls_log/test_cls_log.cc index a726e1cf49f88..a52604659f85c 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"; @@ -79,11 +82,10 @@ void generate_log(librados::IoCtx& ioctx, string& oid, int max, utime_t& start_t int i; for (i = 0; i < max; i++) { - 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); @@ -92,19 +94,16 @@ 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) { - 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); @@ -112,7 +111,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) @@ -125,7 +124,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; @@ -136,7 +135,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); } @@ -150,8 +149,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; @@ -211,13 +210,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 */ @@ -248,7 +247,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()); @@ -280,7 +279,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, "", ""); @@ -296,7 +295,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; @@ -305,12 +304,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)); @@ -327,10 +326,9 @@ 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); - utime_t zero_time; std::vector log1; { vector entries; diff --git a/src/test/rgw/test_log_backing.cc b/src/test/rgw/test_log_backing.cc index 155e341d35dc5..e03ee0c5f12dc 100644 --- a/src/test/rgw/test_log_backing.cc +++ b/src/test/rgw/test_log_backing.cc @@ -72,7 +72,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), &op, null_yield); ASSERT_GE(r, 0); } @@ -83,7 +83,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), &op, null_yield); ASSERT_GE(r, 0); } -- 2.39.5