RGW - Zipper - Remove StatOp

As part of removing RGWObjManifest from the Zipper API, we need to
remove StatOp.  It's only used by orphan list, which is part of the
RadosStore.

Signed-off-by: Daniel Gryniewicz <dang@redhat.com>

diff --git a/src/rgw/rgw_admin.cc b/src/rgw/rgw_admin.cc
index d69a9e99f6aee48fa8c0ea4a672c5bf9256efd8f..71ba340d12b5e76c793c8d6c6daef653c5c67d03 100644 (file)
--- a/src/rgw/rgw_admin.cc
+++ b/src/rgw/rgw_admin.cc
@@ -6307,7 +6307,7 @@ int main(int argc, const char **argv)
   } /* OPT::BUCKETS_LIST */
 
   if (opt_cmd == OPT::BUCKET_RADOS_LIST) {
-    RGWRadosList lister(store,
+    RGWRadosList lister(static_cast<rgw::sal::RadosStore*>(store),
                        max_concurrent_ios, orphan_stale_secs, tenant);
     if (rgw_obj_fs) {
       lister.set_field_separator(*rgw_obj_fs);
@@ -7514,7 +7514,7 @@ next:
           << std::endl;
     }
 
-    RGWOrphanSearch search(store, max_concurrent_ios, orphan_stale_secs);
+    RGWOrphanSearch search(static_cast<rgw::sal::RadosStore*>(store), max_concurrent_ios, orphan_stale_secs);
 
     if (job_id.empty()) {
       cerr << "ERROR: --job-id not specified" << std::endl;
@@ -7554,7 +7554,7 @@ next:
           << std::endl;
     }
 
-    RGWOrphanSearch search(store, max_concurrent_ios, orphan_stale_secs);
+    RGWOrphanSearch search(static_cast<rgw::sal::RadosStore*>(store), max_concurrent_ios, orphan_stale_secs);
 
     if (job_id.empty()) {
       cerr << "ERROR: --job-id not specified" << std::endl;
@@ -7584,7 +7584,7 @@ next:
           << std::endl;
     }
 
-    RGWOrphanStore orphan_store(store);
+    RGWOrphanStore orphan_store(static_cast<rgw::sal::RadosStore*>(store));
     int ret = orphan_store.init(dpp());
     if (ret < 0){
       cerr << "connection to cluster failed!" << std::endl;

diff --git a/src/rgw/rgw_orphan.cc b/src/rgw/rgw_orphan.cc
index 661bbc9e35029ff52fa29a5de3e4d7462daf0140..3d19f4366fb8310ee49688c55c81521350b944c6 100644 (file)
--- a/src/rgw/rgw_orphan.cc
+++ b/src/rgw/rgw_orphan.cc
@@ -429,12 +429,12 @@ int RGWOrphanSearch::build_buckets_instance_index(const DoutPrefixProvider *dpp)
   return 0;
 }
 
-int RGWOrphanSearch::handle_stat_result(const DoutPrefixProvider *dpp, map<int, list<string> >& oids, rgw::sal::Object::StatOp::Result& result)
+int RGWOrphanSearch::handle_stat_result(const DoutPrefixProvider *dpp, map<int, list<string> >& oids, RGWRados::Object::Stat::Result& result)
 {
   set<string> obj_oids;
-  rgw::sal::Bucket* bucket = result.obj->get_bucket();
+  rgw_bucket& bucket = result.obj.bucket;
   if (!result.manifest) { /* a very very old object, or part of a multipart upload during upload */
-    const string loc = bucket->get_bucket_id() + "_" + result.obj->get_oid();
+    const string loc = bucket.bucket_id + "_" + result.obj.get_oid();
     obj_oids.insert(obj_fingerprint(loc));
 
     /*
@@ -469,18 +469,18 @@ int RGWOrphanSearch::handle_stat_result(const DoutPrefixProvider *dpp, map<int,
   return 0;
 }
 
-int RGWOrphanSearch::pop_and_handle_stat_op(const DoutPrefixProvider *dpp, map<int, list<string> >& oids, std::deque<std::unique_ptr<rgw::sal::Object::StatOp>>& ops)
+int RGWOrphanSearch::pop_and_handle_stat_op(const DoutPrefixProvider *dpp, map<int, list<string> >& oids, std::deque<RGWRados::Object::Stat>& ops)
 {
-  rgw::sal::Object::StatOp* front_op = ops.front().get();
+  RGWRados::Object::Stat& front_op = ops.front();
 
-  int ret = front_op->wait(dpp);
+  int ret = front_op.wait(dpp);
   if (ret < 0) {
     if (ret != -ENOENT) {
       ldpp_dout(dpp, -1) << "ERROR: stat_async() returned error: " << cpp_strerror(-ret) << dendl;
     }
     goto done;
   }
-  ret = handle_stat_result(dpp, oids, front_op->result);
+  ret = handle_stat_result(dpp, oids, front_op.result);
   if (ret < 0) {
     ldpp_dout(dpp, -1) << "ERROR: handle_stat_response() returned error: " << cpp_strerror(-ret) << dendl;
   }
@@ -541,25 +541,29 @@ int RGWOrphanSearch::build_linked_oids_for_bucket(const DoutPrefixProvider *dpp,
   }
 
   ldpp_dout(dpp, 10) << "building linked oids for bucket instance: " << bucket_instance_id << dendl;
-  rgw::sal::Bucket::ListParams params;
-  rgw::sal::Bucket::ListResults results;
+  RGWRados::Bucket target(store->getRados(), cur_bucket->get_info());
+  RGWRados::Bucket::List list_op(&target);
 
   string marker;
-  params.marker = rgw_obj_key(marker);
-  params.list_versions = true;
-  params.enforce_ns = false;
+  list_op.params.marker = rgw_obj_key(marker);
+  list_op.params.list_versions = true;
+  list_op.params.enforce_ns = false;
 
-  std::deque<std::unique_ptr<rgw::sal::Object>> objs;
-  std::deque<std::unique_ptr<rgw::sal::Object::StatOp>> stat_ops;
+  bool truncated;
+
+  deque<RGWRados::Object::Stat> stat_ops;
 
   do {
-    ret = bucket->list(dpp, params, max_list_bucket_entries, results, null_yield);
+    vector<rgw_bucket_dir_entry> result;
+
+    ret = list_op.list_objects(dpp, max_list_bucket_entries,
+                               &result, nullptr, &truncated, null_yield);
     if (ret < 0) {
       cerr << "ERROR: store->list_objects(): " << cpp_strerror(-ret) << std::endl;
       return ret;
     }
 
-    for (vector<rgw_bucket_dir_entry>::iterator iter = results.objs.begin(); iter != results.objs.end(); ++iter) {
+    for (vector<rgw_bucket_dir_entry>::iterator iter = result.begin(); iter != result.end(); ++iter) {
       rgw_bucket_dir_entry& entry = *iter;
       if (entry.key.instance.empty()) {
         ldpp_dout(dpp, 20) << "obj entry: " << entry.key.name << dendl;
@@ -576,15 +580,14 @@ int RGWOrphanSearch::build_linked_oids_for_bucket(const DoutPrefixProvider *dpp,
         continue;
       }
 
-      std::unique_ptr<rgw::sal::Object> obj = bucket->get_object(entry.key);
-      std::unique_ptr<rgw::sal::Object::StatOp> stat_op = obj->get_stat_op(&obj_ctx);
-      rgw::sal::Object::StatOp* op = stat_op.get();
+      rgw_obj obj(cur_bucket->get_key(), entry.key);
 
-      objs.push_back(std::move(obj));
-      stat_ops.push_back(std::move(stat_op));
+      RGWRados::Object op_target(store->getRados(), cur_bucket->get_info(), obj_ctx, obj);
 
+      stat_ops.push_back(RGWRados::Object::Stat(&op_target));
+      RGWRados::Object::Stat& op = stat_ops.back();
 
-      ret = op->stat_async(dpp);
+      ret = op.stat_async(dpp);
       if (ret < 0) {
         ldpp_dout(dpp, -1) << "ERROR: stat_async() returned error: " << cpp_strerror(-ret) << dendl;
         return ret;
@@ -606,7 +609,7 @@ int RGWOrphanSearch::build_linked_oids_for_bucket(const DoutPrefixProvider *dpp,
         oids.clear();
       }
     }
-  } while (results.is_truncated);
+  } while (truncated);
 
   while (!stat_ops.empty()) {
     ret = pop_and_handle_stat_op(dpp, oids, stat_ops);
@@ -923,23 +926,23 @@ int RGWOrphanSearch::finish()
 
 
 int RGWRadosList::handle_stat_result(const DoutPrefixProvider *dpp,
-                                     rgw::sal::Object::StatOp::Result& result,
+                                    RGWRados::Object::Stat::Result& result,
                                     std::string& bucket_name,
                                     rgw_obj_key& obj_key,
                                      std::set<string>& obj_oids)
 {
   obj_oids.clear();
 
-  rgw::sal::Bucket* bucket = result.obj->get_bucket();
+  rgw_bucket& bucket = result.obj.bucket;
 
   ldpp_dout(dpp, 20) << "RGWRadosList::" << __func__ <<
     " bucket=" << bucket <<
-    ", has_manifest=" << !!result.manifest <<
+    ", has_manifest=" << result.manifest.has_value() <<
     dendl;
 
   // iterator to store result of dlo/slo attribute find
-  auto attr_it = result.obj->get_attrs().end();
-  const std::string oid = bucket->get_marker() + "_" + result.obj->get_oid();
+  decltype(result.attrs)::iterator attr_it = result.attrs.end();
+  const std::string oid = bucket.marker + "_" + result.obj.get_oid();
   ldpp_dout(dpp, 20) << "radoslist processing object=\"" <<
       oid << "\"" << dendl;
   if (visited_oids.find(oid) != visited_oids.end()) {
@@ -950,8 +953,8 @@ int RGWRadosList::handle_stat_result(const DoutPrefixProvider *dpp,
     return 0;
   }
 
-  bucket_name = bucket->get_name();
-  obj_key = result.obj->get_key();
+  bucket_name = bucket.name;
+  obj_key = result.obj.key;
 
   if (!result.manifest) {
     /* a very very old object, or part of a multipart upload during upload */
@@ -962,8 +965,8 @@ int RGWRadosList::handle_stat_result(const DoutPrefixProvider *dpp,
      * object; we'll process them in
      * RGWRadosList::do_incomplete_multipart
      */
-  } else if ((attr_it = result.obj->get_attrs().find(RGW_ATTR_USER_MANIFEST)) !=
-            result.obj->get_attrs().end()) {
+  } else if ((attr_it = result.attrs.find(RGW_ATTR_USER_MANIFEST)) !=
+            result.attrs.end()) {
     // *** handle DLO object ***
 
     obj_oids.insert(oid);
@@ -986,8 +989,8 @@ int RGWRadosList::handle_stat_result(const DoutPrefixProvider *dpp,
     ldpp_dout(dpp, 25) << "radoslist DLO oid=\"" << oid <<
       "\" added bucket=\"" << bucket_name << "\" prefix=\"" <<
       prefix << "\" to process list" << dendl;
-  } else if ((attr_it = result.obj->get_attrs().find(RGW_ATTR_SLO_MANIFEST)) !=
-            result.obj->get_attrs().end()) {
+  } else if ((attr_it = result.attrs.find(RGW_ATTR_USER_MANIFEST)) !=
+            result.attrs.end()) {
     // *** handle SLO object ***
 
     obj_oids.insert(oid);
@@ -1052,14 +1055,14 @@ int RGWRadosList::handle_stat_result(const DoutPrefixProvider *dpp,
 int RGWRadosList::pop_and_handle_stat_op(
   const DoutPrefixProvider *dpp,
   RGWObjectCtx& obj_ctx,
-  std::deque<std::unique_ptr<rgw::sal::Object::StatOp>>& ops)
+  std::deque<RGWRados::Object::Stat>& ops)
 {
   std::string bucket_name;
   rgw_obj_key obj_key;
   std::set<std::string> obj_oids;
-  std::unique_ptr<rgw::sal::Object::StatOp> front_op = std::move(ops.front());
+  RGWRados::Object::Stat& front_op = ops.front();
 
-  int ret = front_op->wait(dpp);
+  int ret = front_op.wait(dpp);
   if (ret < 0) {
     if (ret != -ENOENT) {
       ldpp_dout(dpp, -1) << "ERROR: stat_async() returned error: " <<
@@ -1068,7 +1071,7 @@ int RGWRadosList::pop_and_handle_stat_op(
     goto done;
   }
 
-  ret = handle_stat_result(dpp, front_op->result, bucket_name, obj_key, obj_oids);
+  ret = handle_stat_result(dpp, front_op.result, bucket_name, obj_key, obj_oids);
   if (ret < 0) {
     ldpp_dout(dpp, -1) << "ERROR: handle_stat_result() returned error: " <<
       cpp_strerror(-ret) << dendl;
@@ -1090,7 +1093,7 @@ done:
 
   // invalidate object context for this object to avoid memory leak
   // (see pr https://github.com/ceph/ceph/pull/30174)
-  obj_ctx.invalidate(front_op->result.obj->get_obj());
+  obj_ctx.invalidate(front_op.result.obj);
 
   ops.pop_front();
   return ret;
@@ -1167,10 +1170,15 @@ int RGWRadosList::process_bucket(
     ", prefix=" << prefix <<
     ", entries_filter.size=" << entries_filter.size() << dendl;
 
-  rgw_bucket b;
-  rgw_bucket_parse_bucket_key(store->ctx(), bucket_instance_id, &b, nullptr);
-  std::unique_ptr<rgw::sal::Bucket> bucket;
-  int ret = store->get_bucket(dpp, nullptr, b, &bucket, null_yield);
+  RGWBucketInfo bucket_info;
+  RGWSysObjectCtx sys_obj_ctx = store->svc()->sysobj->init_obj_ctx();
+  int ret = store->getRados()->get_bucket_instance_info(sys_obj_ctx,
+                                                       bucket_instance_id,
+                                                       bucket_info,
+                                                       nullptr,
+                                                       nullptr,
+                                                       null_yield,
+                                                        dpp);
   if (ret < 0) {
     if (ret == -ENOENT) {
       // probably raced with bucket removal
@@ -1182,25 +1190,28 @@ int RGWRadosList::process_bucket(
     return ret;
   }
 
-  rgw::sal::Bucket::ListParams params;
-  rgw::sal::Bucket::ListResults results;
+  RGWRados::Bucket target(store->getRados(), bucket_info);
+  RGWRados::Bucket::List list_op(&target);
 
   std::string marker;
-  params.marker = rgw_obj_key(marker);
-  params.list_versions = true;
-  params.enforce_ns = false;
-  params.allow_unordered = false;
-  params.prefix = prefix;
-
-  std::deque<std::unique_ptr<rgw::sal::Object>> objs;
-  std::deque<std::unique_ptr<rgw::sal::Object::StatOp>> stat_ops;
+  list_op.params.marker = rgw_obj_key(marker);
+  list_op.params.list_versions = true;
+  list_op.params.enforce_ns = false;
+  list_op.params.allow_unordered = false;
+  list_op.params.prefix = prefix;
+
+  bool truncated;
+
+  std::deque<RGWRados::Object::Stat> stat_ops;
   std::string prev_versioned_key_name = "";
 
   RGWObjectCtx obj_ctx(store);
 
   do {
+    std::vector<rgw_bucket_dir_entry> result;
     constexpr int64_t LIST_OBJS_MAX_ENTRIES = 100;
-    ret = bucket->list(dpp, params, LIST_OBJS_MAX_ENTRIES, results, null_yield);
+    ret = list_op.list_objects(dpp, LIST_OBJS_MAX_ENTRIES, &result,
+                              NULL, &truncated, null_yield);
     if (ret == -ENOENT) {
       // race with bucket delete?
       ret = 0;
@@ -1211,8 +1222,8 @@ int RGWRadosList::process_bucket(
       return ret;
     }
 
-    for (std::vector<rgw_bucket_dir_entry>::iterator iter = results.objs.begin();
-        iter != results.objs.end();
+    for (std::vector<rgw_bucket_dir_entry>::iterator iter = result.begin();
+        iter != result.end();
         ++iter) {
       rgw_bucket_dir_entry& entry = *iter;
 
@@ -1238,14 +1249,14 @@ int RGWRadosList::process_bucket(
        [&](const rgw_obj_key& key) -> int {
          int ret;
 
-         std::unique_ptr<rgw::sal::Object> obj = bucket->get_object(key);
-         std::unique_ptr<rgw::sal::Object::StatOp> stat_op = obj->get_stat_op(&obj_ctx);
-         rgw::sal::Object::StatOp* op = stat_op.get();
+         rgw_obj obj(bucket_info.bucket, key);
+         RGWRados::Object op_target(store->getRados(), bucket_info,
+                                    obj_ctx, obj);
 
-         objs.push_back(std::move(obj));
-         stat_ops.push_back(std::move(stat_op));
+         stat_ops.push_back(RGWRados::Object::Stat(&op_target));
+         RGWRados::Object::Stat& op = stat_ops.back();
 
-         ret = op->stat_async(dpp);
+         ret = op.stat_async(dpp);
          if (ret < 0) {
            ldpp_dout(dpp, -1) << "ERROR: stat_async() returned error: " <<
              cpp_strerror(-ret) << dendl;
@@ -1292,7 +1303,7 @@ int RGWRadosList::process_bucket(
        return ret;
       }
     } // for iter loop
-  } while (results.is_truncated);
+  } while (truncated);
 
   while (!stat_ops.empty()) {
     ret = pop_and_handle_stat_op(dpp, obj_ctx, stat_ops);

diff --git a/src/rgw/rgw_orphan.h b/src/rgw/rgw_orphan.h
index e51dfe6d3f64fe3fe924205b9b80ebc5b07dfc56..a5081374e88fdb44a4691c66c63bf681758a35de 100644 (file)
--- a/src/rgw/rgw_orphan.h
+++ b/src/rgw/rgw_orphan.h
@@ -19,7 +19,7 @@
 #include "common/Formatter.h"
 #include "common/errno.h"
 
-#include "rgw_sal.h"
+#include "rgw_sal_rados.h"
 
 #define dout_subsys ceph_subsys_rgw
 
@@ -123,13 +123,13 @@ struct RGWOrphanSearchState {
 WRITE_CLASS_ENCODER(RGWOrphanSearchState)
 
 class RGWOrphanStore {
-  rgw::sal::Store* store;
+  rgw::sal::RadosStore* store;
   librados::IoCtx ioctx;
 
   std::string oid;
 
 public:
-  explicit RGWOrphanStore(rgw::sal::Store* _store) : store(_store), oid(RGW_ORPHAN_INDEX_OID) {}
+  explicit RGWOrphanStore(rgw::sal::RadosStore* _store) : store(_store), oid(RGW_ORPHAN_INDEX_OID) {}
 
   librados::IoCtx& get_ioctx() { return ioctx; }
 
@@ -147,7 +147,7 @@ public:
 
 
 class RGWOrphanSearch {
-  rgw::sal::Store* store;
+  rgw::sal::RadosStore* store;
 
   RGWOrphanStore orphan_store;
 
@@ -179,12 +179,12 @@ class RGWOrphanSearch {
     return ceph_str_hash_linux(str.c_str(), str.size()) % RGW_ORPHANSEARCH_HASH_PRIME % search_info.num_shards;
   }
 
-  int handle_stat_result(const DoutPrefixProvider *dpp, std::map<int, std::list<std::string> >& oids, rgw::sal::Object::StatOp::Result& result);
-  int pop_and_handle_stat_op(const DoutPrefixProvider *dpp, std::map<int, std::list<std::string> >& oids, std::deque<std::unique_ptr<rgw::sal::Object::StatOp>>& ops);
+  int handle_stat_result(const DoutPrefixProvider *dpp, std::map<int, std::list<std::string> >& oids, RGWRados::Object::Stat::Result& result);
+  int pop_and_handle_stat_op(const DoutPrefixProvider *dpp, std::map<int, std::list<std::string> >& oids, std::deque<RGWRados::Object::Stat>& ops);
 
   int remove_index(std::map<int, std::string>& index);
 public:
-  RGWOrphanSearch(rgw::sal::Store* _store, int _max_ios, uint64_t _stale_secs) : store(_store), orphan_store(store), max_concurrent_ios(_max_ios), stale_secs(_stale_secs) {}
+  RGWOrphanSearch(rgw::sal::RadosStore* _store, int _max_ios, uint64_t _stale_secs) : store(_store), orphan_store(store), max_concurrent_ios(_max_ios), stale_secs(_stale_secs) {}
 
   int save_state() {
     RGWOrphanSearchState state;
@@ -250,7 +250,7 @@ class RGWRadosList {
     p.first->second.filter_keys.insert(obj_key);
   }
 
-  rgw::sal::Store* store;
+  rgw::sal::RadosStore* store;
 
   uint16_t max_concurrent_ios;
   uint64_t stale_secs;
@@ -260,17 +260,17 @@ class RGWRadosList {
   std::string field_separator;
 
   int handle_stat_result(const DoutPrefixProvider *dpp,
-                         rgw::sal::Object::StatOp::Result& result,
+                        RGWRados::Object::Stat::Result& result,
                         std::string& bucket_name,
                         rgw_obj_key& obj_key,
                         std::set<std::string>& obj_oids);
   int pop_and_handle_stat_op(const DoutPrefixProvider *dpp, 
                              RGWObjectCtx& obj_ctx,
-                            std::deque<std::unique_ptr<rgw::sal::Object::StatOp>>& ops);
+                            std::deque<RGWRados::Object::Stat>& ops);
 
 public:
 
-  RGWRadosList(rgw::sal::Store* _store,
+  RGWRadosList(rgw::sal::RadosStore* _store,
               int _max_ios,
               uint64_t _stale_secs,
               const std::string& _tenant_name) :

diff --git a/src/rgw/rgw_sal.h b/src/rgw/rgw_sal.h
index 4299c27dd0aa72495e428e10076a9b74e15f3e8a..fcd8de14eab704c5f8a0bacfeabd01b8041f4679 100644 (file)
--- a/src/rgw/rgw_sal.h
+++ b/src/rgw/rgw_sal.h
@@ -628,18 +628,6 @@ class Object {
       virtual int delete_obj(const DoutPrefixProvider* dpp, optional_yield y) = 0;
     };
 
-    struct StatOp {
-      struct Result {
-       Object* obj;
-        RGWObjManifest* manifest;
-      } result;
-
-      virtual ~StatOp() = default;
-
-      virtual int stat_async(const DoutPrefixProvider *dpp) = 0;
-      virtual int wait(const DoutPrefixProvider *dpp) = 0;
-    };
-
     Object()
       : key(),
       bucket(nullptr),
@@ -753,7 +741,6 @@ class Object {
     /* OPs */
     virtual std::unique_ptr<ReadOp> get_read_op(RGWObjectCtx*) = 0;
     virtual std::unique_ptr<DeleteOp> get_delete_op(RGWObjectCtx*) = 0;
-    virtual std::unique_ptr<StatOp> get_stat_op(RGWObjectCtx*) = 0;
 
     /* OMAP */
     virtual int omap_get_vals(const DoutPrefixProvider *dpp, const std::string& marker, uint64_t count,

diff --git a/src/rgw/rgw_sal_rados.cc b/src/rgw/rgw_sal_rados.cc
index a7aff70c1b9da0dc103a8b13c415dd9c9eab5567..fa0612297d23dc957c519fd8f02a6cfe2c601c6a 100644 (file)
--- a/src/rgw/rgw_sal_rados.cc
+++ b/src/rgw/rgw_sal_rados.cc
@@ -1916,47 +1916,6 @@ int RadosObject::delete_obj_aio(const DoutPrefixProvider* dpp, RGWObjState* asta
                                           raio->handles, keep_index_consistent, y);
 }
 
-std::unique_ptr<Object::StatOp> RadosObject::get_stat_op(RGWObjectCtx* ctx)
-{
-  return std::unique_ptr<Object::StatOp>(new RadosObject::RadosStatOp(this, ctx));
-}
-
-RadosObject::RadosStatOp::RadosStatOp(RadosObject *_source, RGWObjectCtx *_rctx) :
-       source(_source),
-       rctx(_rctx),
-       op_target(_source->store->getRados(),
-                 _source->get_bucket()->get_info(),
-                 *static_cast<RGWObjectCtx *>(rctx),
-                 _source->get_obj()),
-       parent_op(&op_target)
-{ }
-
-int RadosObject::RadosStatOp::stat_async(const DoutPrefixProvider *dpp)
-{
-  return parent_op.stat_async(dpp);
-}
-
-int RadosObject::RadosStatOp::wait(const DoutPrefixProvider *dpp)
-{
-  result.obj = source;
-  int ret =  parent_op.wait(dpp);
-  if (ret < 0)
-    return ret;
-
-  source->obj_size = parent_op.result.size;
-  source->mtime = ceph::real_clock::from_timespec(parent_op.result.mtime);
-  source->attrs = parent_op.result.attrs;
-  source->key = parent_op.result.obj.key;
-  source->in_extra_data = parent_op.result.obj.in_extra_data;
-  source->index_hash_source = parent_op.result.obj.index_hash_source;
-  if (parent_op.result.manifest)
-    result.manifest = &(*parent_op.result.manifest);
-  else
-    result.manifest = nullptr;
-
-  return ret;
-}
-
 int RadosObject::copy_object(RGWObjectCtx& obj_ctx,
                                User* user,
                                req_info* info,

diff --git a/src/rgw/rgw_sal_rados.h b/src/rgw/rgw_sal_rados.h
index 21627cea6e650e013c381d0a012f74e4170fdeb7..bb6bd4df099d68d465b11659e218e6008dd635fc 100644 (file)
--- a/src/rgw/rgw_sal_rados.h
+++ b/src/rgw/rgw_sal_rados.h
@@ -111,20 +111,6 @@ class RadosObject : public Object {
       virtual int delete_obj(const DoutPrefixProvider* dpp, optional_yield y) override;
     };
 
-    struct RadosStatOp : public StatOp {
-    private:
-      RadosObject* source;
-      RGWObjectCtx* rctx;
-      RGWRados::Object op_target;
-      RGWRados::Object::Stat parent_op;
-
-    public:
-      RadosStatOp(RadosObject* _source, RGWObjectCtx* _rctx);
-
-      virtual int stat_async(const DoutPrefixProvider *dpp) override;
-      virtual int wait(const DoutPrefixProvider *dpp) override;
-    };
-
     RadosObject() = default;
 
     RadosObject(RadosStore *_st, const rgw_obj_key& _k)
@@ -204,7 +190,6 @@ class RadosObject : public Object {
     /* OPs */
     virtual std::unique_ptr<ReadOp> get_read_op(RGWObjectCtx *) override;
     virtual std::unique_ptr<DeleteOp> get_delete_op(RGWObjectCtx*) override;
-    virtual std::unique_ptr<StatOp> get_stat_op(RGWObjectCtx*) override;
 
     /* OMAP */
     virtual int omap_get_vals(const DoutPrefixProvider *dpp, const std::string& marker, uint64_t count,