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 50e0d743dc5c0558a41e13ecf2d589e4685b8b36..6d0c687e996a316582d8278b895a30012a2c1fca 100644 (file)
--- 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<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";
   }
@@ -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 7b00fe501568f8a41358d09c6725447b07ffb4e1..f137dbbfca6d3abd8301d0379c1ddac3e346bdb4 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);

diff --git a/src/rgw/driver/rados/rgw_datalog.cc b/src/rgw/driver/rados/rgw_datalog.cc
index 403239077d284b7cc06f7cf9580778b5bcc16992..ea2a3548ad45a612d03b28e995f067d0ed770807 100644 (file)
--- 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<centries>(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 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 8b5768c86b68afc0d1c3a21c0eb718a2d2a881ee..182b81655659e08bff83f89489eceef4d7d82f70 100644 (file)
--- 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 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 a6d75de0eba12ecffc9d12009f4400443e6482a0..d1f1a32d4fd69599f9b7bd3d1044d93dca21066e 100644 (file)
--- 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 7ebc0e409118def7764a98d5c26f79c1d927741d..c076f72cab475bf8a2b6b3378c9a527bb7114269 100644 (file)
--- 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 a726e1cf49f88d7c6208fd0f02400f3d36e6ed0d..a52604659f85c7cf826225589b721d6214d174db 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";
 
@@ -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<cls_log_entry>& 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<cls_log_entry>& 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<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);
 }
@@ -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<cls_log_entry> 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<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 */
@@ -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<cls_log_entry> 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<cls_log_entry> log1;
   {
     vector<cls_log_entry> entries;

diff --git a/src/test/rgw/test_log_backing.cc b/src/test/rgw/test_log_backing.cc
index 155e341d35dc585d87d644820dc236f3f03d1e24..e03ee0c5f12dcf13ba28388f12fb03aae1f152c4 100644 (file)
--- 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);
   }