cls/log: Switch from utime_t to ceph::real_time

Signed-off-by: Adam C. Emerson <aemerson@redhat.com>

diff --git a/src/cls/log/cls_log.cc b/src/cls/log/cls_log.cc
index 58a8524da34123b7ed0a2c128afa81e3e985bbfb..65b070756e7128ce4e37e63b42d3d03a8cb9cf20 100644 (file)
--- 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 18510b6b2fabf029e36c3d58ae4025e51d437e8a..531cb765f72806a1622dccd10424ab05b732bdba 100644 (file)
--- 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<cls_log_entry>& 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 5187b55756786b718fd3ca753586559d8eeec818..12cd88c2601706d4dd8d0eba5e594b15b83f8f01 100644 (file)
--- 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<cls_log_entry>& 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<cls_log_entry>& 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 82207d52100ffb9a668fd2ce0774bf5bb385d123..a1477ccc6034130b8eb058c6dd1e062c81a15101 100644 (file)
--- 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<cls_log_add_op *>& 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<cls_log_list_op*>& 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<cls_log_list_ret*>& 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<cls_log_trim_op*>& 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 c0be051336691cfdcb2cc765d05c2397828a31fb..c96b56503f79cda359dc6d7946a9687ab6a72d62 100644 (file)
--- 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 99b3fedab44b3dad077724f30f125a85ede54633..7988fc122d9869ace87d789bd18c5d13ecfa6061 100644 (file)
--- 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<centries>(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 8878ae6c7c646863a4925979f031d57ae5ab3dbe..988087ca97a938afb4d2f0a75fa48253d6cde666 100644 (file)
--- 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 3546bbe6bc32fffec33400cd62154247c9263dd2..a2e5446b1ab73c480cd3463877ae814c6e4e3161 100644 (file)
--- 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 f0ee28056afa73e902418f1bb82178a376c8e31c..e7d482abac81fe0b94620b8e584e90f29211fda3 100644 (file)
--- 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 92b03e41bcdc15a15e7c90399e7ffe716850ec51..fe1bc71d8207e684507ada1eecc8b6932ba97d8a 100644 (file)
--- 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 de4d95315579348503f2dd199f73dc377d552a81..76ff34bc8310629afacf47bb5c562ea481632695 100644 (file)
--- 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 fdb4b78490019b5e6f9c22a21d2e754c3c92830c..e725bc87c2acfb5b5e697d9831deaebc9d06266c 100644 (file)
--- 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 <vector>
 
 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<cls_log_entry>& 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<cls_log_entry>& 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<cls_log_entry>& 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<cls_log_entry> 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<cls_log_entry> 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<cls_log_entry> 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<cls_log_entry> log1;

diff --git a/src/test/rgw/test_log_backing.cc b/src/test/rgw/test_log_backing.cc
index 248617e30bc1db44b530452ad960283a9d22177b..79e90f83a50b25e6f1e1c9369e925db530d42403 100644 (file)
--- 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);
   }