rgw: more work towards updated bucket meta interfaces

Signed-off-by: Yehuda Sadeh <yehuda@redhat.com>

diff --git a/src/rgw/rgw_bucket.cc b/src/rgw/rgw_bucket.cc
index 76b6207bed282803a7d345cf621a7c7bceb4b767..141dc936c1b453a48eedb8b515bcd6e16bf85a2f 100644 (file)
--- a/src/rgw/rgw_bucket.cc
+++ b/src/rgw/rgw_bucket.cc
@@ -428,28 +428,6 @@ static int convert_old_bucket_info(RGWRados *store,
   return 0;
 }
 
-int rgw_bucket_set_attrs(RGWRados *store, RGWBucketInfo& bucket_info,
-                         map<string, bufferlist>& attrs,
-                         RGWObjVersionTracker *objv_tracker,
-                         optional_yield y)
-{
-  rgw_bucket& bucket = bucket_info.bucket;
-
-  if (!bucket_info.has_instance_obj) {
-    /* an old bucket object, need to convert it */
-    RGWSysObjectCtx obj_ctx = store->svc.sysobj->init_obj_ctx();
-    int ret = convert_old_bucket_info(store, obj_ctx, bucket.tenant, bucket.name);
-    if (ret < 0) {
-      ldout(store->ctx(), 0) << "ERROR: failed converting old bucket info: " << ret << dendl;
-      return ret;
-    }
-  }
-
-  bufferlist bl;
-
-  return store->svc.bucket->store_bucket_instance_info(bucket_info, false, attrs, objv_tracker, real_time(), y);
-}
-
 static void dump_mulipart_index_results(list<rgw_obj_index_key>& objs_to_unlink,
         Formatter *f)
 {
@@ -815,7 +793,7 @@ int RGWBucket::init(RGWRados *storage, RGWBucketAdminOpState& op_state)
   }
 
   if (!user_id.empty()) {
-    int r = rgw_get_user_info_by_uid(store, user_id, user_info);
+    int r = store->ctl.user->get_info_by_uid(user_id, &user_info);
     if (r < 0)
       return r;
 
@@ -1671,11 +1649,11 @@ int RGWBucketAdminOp::info(RGWRados *store, RGWBucketAdminOpState& op_state,
     bool truncated = true;
 
     formatter->open_array_section("buckets");
-    ret = store->svc.meta->get_mgr()->list_keys_init("bucket", &handle);
+    ret = store->ctl.meta.mgr->list_keys_init("bucket", &handle);
     while (ret == 0 && truncated) {
       std::list<std::string> buckets;
       const int max_keys = 1000;
-      ret = store->svc.meta->get_mgr()->list_keys_next(handle, max_keys, buckets,
+      ret = store->ctl.meta.mgr->list_keys_next(handle, max_keys, buckets,
                                             &truncated);
       for (auto& bucket_name : buckets) {
         if (show_stats)
@@ -1831,7 +1809,7 @@ static int process_stale_instances(RGWRados *store, RGWBucketAdminOpState& op_st
   Formatter *formatter = flusher.get_formatter();
   static constexpr auto default_max_keys = 1000;
 
-  int ret = store->svc.meta->get_mgr()->list_keys_init("bucket.instance", marker, &handle);
+  int ret = store->ctl.meta.mgr->list_keys_init("bucket.instance", marker, &handle);
   if (ret < 0) {
     cerr << "ERROR: can't get key: " << cpp_strerror(-ret) << std::endl;
     return ret;
@@ -1844,7 +1822,7 @@ static int process_stale_instances(RGWRados *store, RGWBucketAdminOpState& op_st
   do {
     list<std::string> keys;
 
-    ret = store->svc.meta->get_mgr()->list_keys_next(handle, default_max_keys, keys, &truncated);
+    ret = store->ctl.meta.mgr->list_keys_next(handle, default_max_keys, keys, &truncated);
     if (ret < 0 && ret != -ENOENT) {
       cerr << "ERROR: lists_keys_next(): " << cpp_strerror(-ret) << std::endl;
       return ret;
@@ -1895,7 +1873,7 @@ int RGWBucketAdminOp::clear_stale_instances(RGWRados *store,
                        int ret = purge_bucket_instance(store, binfo);
                        if (ret == 0){
                          auto md_key = "bucket.instance:" + binfo.bucket.get_key();
-                         ret = store->svc.meta->get_mgr()->remove(md_key);
+                         ret = store->ctl.meta.mgr->remove(md_key);
                        }
                        formatter->open_object_section("delete_status");
                        formatter->dump_string("bucket_instance", binfo.bucket.get_key());
@@ -2531,9 +2509,9 @@ class RGW_MB_Handler_Module_Bucket : public RGWSI_MBSObj_Handler_Module {
 public:
   RGW_MB_Handler_Module_Bucket(RGWSI_Zone *_zone_svc) : zone_svc(_zone_svc) {}
 
-  void get_pool_and_oid(const string& key, rgw_pool& pool, string& oid) override {
-    oid = key;
-    pool = zone_svc->get_zone_params().domain_root;
+  void get_pool_and_oid(const string& key, rgw_pool *pool, string *oid) override {
+    *oid = key;
+    *pool = zone_svc->get_zone_params().domain_root;
   }
 };
 
@@ -2546,7 +2524,7 @@ public:
 
   RGWBucketMetadataHandler(RGWSI_Bucket *bucket_svc) {
     svc.bucket = bucket_svc;
-    be_handler = svc.user->get_ep_be_handler();
+    be_handler = svc.bucket->get_ep_be_handler();
   }
 
   RGWSI_MetaBackend_Handler *get_be_handler() {
@@ -2555,16 +2533,11 @@ public:
 
   string get_type() override { return "bucket"; }
 
-  int init_module() override {
-    be_module.reset(new RGW_MB_Handler_Module_Bucket(store->svc.zone));
-    return 0;
-  }
-
   RGWMetadataObject *get_meta_obj(JSONObj *jo, const obj_version& objv, const ceph::real_time& mtime) override {
     RGWBucketEntryPoint be;
 
     try {
-      decode_json_obj(be, obj);
+      decode_json_obj(be, jo);
     } catch (JSONDecoder::err& e) {
       return nullptr;
     }
@@ -2583,7 +2556,7 @@ public:
     if (ret < 0)
       return ret;
 
-    RGWBucketEntryMetadataObject *mdo = new RGWBucketEntryMetadataObject(be, ot.read_version, mtime, attrs);
+    RGWBucketEntryMetadataObject *mdo = new RGWBucketEntryMetadataObject(be, ot.read_version, mtime, std::move(attrs));
 
     *obj = mdo;
 
@@ -2607,7 +2580,7 @@ public:
 
     real_time orig_mtime;
 
-    int ret = svc.bucket->read_bucket_entrypoint_info(op->ctx(), entry, be, &objv_tracker, &orig_mtime, nullptr, y);
+    int ret = svc.bucket->read_bucket_entrypoint_info(op->ctx(), entry, &be, &objv_tracker, &orig_mtime, nullptr, y);
     if (ret < 0)
       return ret;
 
@@ -2618,12 +2591,12 @@ public:
      */
     ret = rgw_unlink_bucket(store, be.owner, tenant_name, bucket_name, false);
     if (ret < 0) {
-      lderr(store->ctx()) << "could not unlink bucket=" << entry << " owner=" << be.owner << dendl;
+      lderr(svc.bucket->ctx()) << "could not unlink bucket=" << entry << " owner=" << be.owner << dendl;
     }
 
-    ret = svc.bucket->remove_bucket_entrypoint_info(op->ctx(), entry, objv_tracker, orig_mtime);
+    ret = svc.bucket->remove_bucket_entrypoint_info(op->ctx(), entry, objv_tracker);
     if (ret < 0) {
-      lderr(store->ctx()) << "could not delete bucket=" << entry << dendl;
+      lderr(svc.bucket->ctx()) << "could not delete bucket=" << entry << dendl;
     }
     /* idempotent */
     return 0;
@@ -2689,22 +2662,22 @@ public:
   }
 };
 
-class RGWMetadataHandlerPut_Bucket : public RGWMetadataHanderPut_SObj
+class RGWMetadataHandlerPut_Bucket : public RGWMetadataHandlerPut_SObj
 {
   RGWBucketMetadataHandler *handler;
   RGWBucketEntryMetadataObject *obj;
 public:
   RGWMetadataHandlerPut_Bucket(RGWBucketMetadataHandler *_handler,
-                               RGWSI_MetaBackend::Context *ctx, string& entry,
+                               RGWSI_MetaBackend_Handler::Op *op, string& entry,
                                RGWMetadataObject *_obj, RGWObjVersionTracker& objv_tracker,
-                               RGWMDLogSyncType type) : RGWMetadataHanderPut_SObj(ctx, entry, obj, objv_tracker, type),
+                               RGWMDLogSyncType type) : RGWMetadataHandlerPut_SObj(handler, op, entry, obj, objv_tracker, type),
                                                         handler(_handler) {
     obj = static_cast<RGWBucketEntryMetadataObject *>(_obj);
   }
   ~RGWMetadataHandlerPut_Bucket() {}
 
   void encode_obj(bufferlist *bl) override {
-    ceph::encode(obj->get_be(), *bl);
+    obj->get_ep().encode(*bl);
   }
 
   int put_checked(RGWMetadataObject *_old_obj) override;
@@ -2716,21 +2689,21 @@ int RGWBucketMetadataHandler::do_put(RGWSI_MetaBackend_Handler::Op *op, string&
                                      RGWObjVersionTracker& objv_tracker,
                                      RGWMDLogSyncType type)
 {
-  RGWMetadataHandlerPut_Bucket op(this, op->ctx(), entry, obj, objv_tracker, type);
-  return do_put(&op);
+  RGWMetadataHandlerPut_Bucket put_op(this, op, entry, obj, objv_tracker, type);
+  return do_put_operate(&put_op);
 }
 
 int RGWMetadataHandlerPut_Bucket::put_checked(RGWMetadataObject *_old_obj)
 {
   RGWBucketEntryMetadataObject *old_obj = static_cast<RGWBucketEntryMetadataObject *>(_old_obj);
 
-  obj->set_pattrs(old_obj->get_attrs());
+  obj->set_pattrs(&old_obj->get_attrs());
 
-  auto& be = obj->get_be();
+  auto& be = obj->get_ep();
   auto mtime = obj->get_mtime();
   auto pattrs = obj->get_pattrs();
 
-  return handler->svc.bucket->store_bucket_entrypoint_info(ctx, entry,
+  return handler->svc.bucket->store_bucket_entrypoint_info(op->ctx(), entry,
                                                            be,
                                                            false,
                                                            mtime,
@@ -2740,7 +2713,9 @@ int RGWMetadataHandlerPut_Bucket::put_checked(RGWMetadataObject *_old_obj)
 
 int RGWMetadataHandlerPut_Bucket::put_post()
 {
-  auto& be = obj->get_be();
+  auto& be = obj->get_ep();
+
+  int ret;
 
   /* link bucket */
   if (be.linked) {
@@ -2816,8 +2791,10 @@ WRITE_CLASS_ENCODER(archive_meta_info)
 
 class RGWArchiveBucketMetadataHandler : public RGWBucketMetadataHandler {
 public:
-  int do_remove(RGWS_MetaBackend_Handler::Op *op, string& entry, RGWObjVersionTracker& objv_tracker,
+  int do_remove(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWObjVersionTracker& objv_tracker,
                 optional_yield y) override {
+    auto cct = svc.bucket->ctx();
+
     ldout(cct, 5) << "SKIP: bucket removal is not allowed on archive zone: bucket:" << entry << " ... proceeding to rename" << dendl;
 
     string tenant_name, bucket_name;
@@ -2829,7 +2806,7 @@ public:
 
     RGWBucketEntryPoint be;
     map<string, bufferlist> attrs;
-    int ret = svc.bucket->read_bucket_entrypoint_info(op->ctx(), entry, be, &objv_tracker, &mtime, &attrs, y);
+    int ret = svc.bucket->read_bucket_entrypoint_info(op->ctx(), entry, &be, &objv_tracker, &mtime, &attrs, y);
     if (ret < 0) {
         return ret;
     }
@@ -2842,14 +2819,14 @@ public:
     ceph::real_time orig_mtime;
     RGWBucketInfo old_bi;
 
-    ret = svc.bucket->read_bucket_instance_info(op->ctx(), bi_meta_key, old_bi, &orig_mtime, &attrs_m, y);
+    ret = svc.bucket->read_bucket_instance_info(op->ctx(), bi_meta_name, &old_bi, &orig_mtime, &attrs_m, y);
     if (ret < 0) {
         return ret;
     }
 
     archive_meta_info ami;
 
-    if (!ami.from_attrs(store->ctx(), attrs_m)) {
+    if (!ami.from_attrs(svc.bucket->ctx(), attrs_m)) {
       ami.orig_bucket = old_bi.bucket;
       ami.store_in_attrs(attrs_m);
     }
@@ -2876,20 +2853,21 @@ public:
 
     new_be.bucket.name = new_bucket_name;
 
-    ret = svc.bucket->store_bucket_instance_info(op->ctx(), new_bi, false, orig_mtime, &attrs_m, y);
+    ret = svc.bucket->store_bucket_instance_info(op->ctx(), bi_meta_name, new_bi, false, orig_mtime, &attrs_m, y);
     if (ret < 0) {
-      ldout(store->ctx(), 0) << "ERROR: failed to put new bucket instance info for bucket=" << new_bi.bucket << " ret=" << ret << dendl;
+      ldout(cct, 0) << "ERROR: failed to put new bucket instance info for bucket=" << new_bi.bucket << " ret=" << ret << dendl;
       return ret;
     }
 
     /* store a new entrypoint */
 
     RGWObjVersionTracker ot;
-    ot.generate_new_write_ver(store->ctx());
+    ot.generate_new_write_ver(cct);
 
-    ret = svc.bucket->store_bucket_entrypoint_info(op->ctx(), new_be.bucket, new_be, true, mtime, &attrs, nullptr, y);
+    ret = svc.bucket->store_bucket_entrypoint_info(op->ctx(), RGWSI_Bucket::get_entrypoint_meta_key(new_be.bucket),
+                                                   new_be, true, mtime, &attrs, nullptr, y);
     if (ret < 0) {
-      ldout(store->ctx(), 0) << "ERROR: failed to put new bucket entrypoint for bucket=" << new_be.bucket << " ret=" << ret << dendl;
+      ldout(cct, 0) << "ERROR: failed to put new bucket entrypoint for bucket=" << new_be.bucket << " ret=" << ret << dendl;
       return ret;
     }
 
@@ -2897,7 +2875,7 @@ public:
 
     ret = rgw_link_bucket(store, new_be.owner, new_be.bucket, new_be.creation_time, false, y);
     if (ret < 0) {
-      ldout(store->ctx(), 0) << "ERROR: failed to link new bucket for bucket=" << new_be.bucket << " ret=" << ret << dendl;
+      ldout(cct, 0) << "ERROR: failed to link new bucket for bucket=" << new_be.bucket << " ret=" << ret << dendl;
       return ret;
     }
 
@@ -2905,7 +2883,7 @@ public:
 
     ret = rgw_unlink_bucket(store, be.owner, tenant_name, bucket_name, false, y);
     if (ret < 0) {
-        lderr(store->ctx()) << "could not unlink bucket=" << entry << " owner=" << be.owner << dendl;
+        lderr(cct) << "could not unlink bucket=" << entry << " owner=" << be.owner << dendl;
     }
 
     // if (ret == -ECANCELED) it means that there was a race here, and someone
@@ -2918,13 +2896,13 @@ public:
                                                     &objv_tracker,
                                                     y);
     if (ret < 0) {
-      ldout(store->ctx(), 0) << "ERROR: failed to put new bucket entrypoint for bucket=" << new_be.bucket << " ret=" << ret << dendl;
+      ldout(cct, 0) << "ERROR: failed to put new bucket entrypoint for bucket=" << new_be.bucket << " ret=" << ret << dendl;
       return ret;
     }
 
     ret = svc.bucket->remove_bucket_instance_info(op->ctx(), bi_meta_name, nullptr, y);
     if (ret < 0) {
-        lderr(store->ctx()) << "could not delete bucket=" << entry << dendl;
+        lderr(cct) << "could not delete bucket=" << entry << dendl;
     }
 
 
@@ -2957,7 +2935,7 @@ public:
     }
 
     return RGWBucketMetadataHandler::do_put(op, entry, objv_tracker,
-                                            mtime, obj, y, sync_type);
+                                            obj->get_mtime(), obj, y, sync_type);
   }
 
 };
@@ -2983,7 +2961,7 @@ class RGWBucketInstanceMetadataHandler : public RGWMetadataHandler {
                                    const ceph::real_time& mtime,
                                    optional_yield y) {
 #warning mtime?
-    return svc.bucket->remove_bucket_instance_info(ctx, entry, objv_tracker, y);
+    return svc.bucket->remove_bucket_instance_info(op->ctx(), entry, objv_tracker, y);
   }
 
 
@@ -2994,7 +2972,7 @@ public:
 
   RGWBucketInstanceMetadataHandler(RGWSI_Bucket *bucket_svc) {
     svc.bucket = bucket_svc;
-    be_handler = svc.user->get_bi_be_handler();
+    be_handler = svc.bucket->get_bi_be_handler();
   }
 
   RGWSI_MetaBackend_Handler *get_be_handler() {
@@ -3018,26 +2996,27 @@ public:
     return 0;
   }
 
-  int do_put(RGWSI_MetaBackend::Context *ctx, string& entry,
+  int do_put(RGWSI_MetaBackend_Handler::Op *op, string& entry,
              RGWMetadataObject *_obj, RGWObjVersionTracker& objv_tracker,
-             RGWMetadataObject *_old_obj) override;
+             RGWMDLogSyncType sync_type) override;
 
   struct list_keys_info {
     RGWRados *store;
     RGWListRawObjsCtx ctx;
   };
 
-  int do_remove(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWObjVersionTracker& objv_tracker) override {
+  int do_remove(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWObjVersionTracker& objv_tracker,
+                optioanl_yield y) override {
     RGWBucketCompleteInfo bci;
 
-    int ret = read_bucket_instance_entry(ctx, entry, bci, nullptr, null_yield);
+    int ret = read_bucket_instance_entry(op, entry, &bci, nullptr, y);
     if (ret < 0 && ret != -ENOENT)
       return ret;
 
-    return svc.bucket->remove_bucket_instance_info(ctx, entry, &bci->info.objv_tracker);
+    return svc.bucket->remove_bucket_instance_info(op->ctx(), entry, &bci.info.objv_tracker);
   }
 
-  int list_keys_init(RGWRados *store, const string& marker, void **phandle) override {
+  int list_keys_init(const string& marker, void **phandle) override {
     auto info = std::make_unique<list_keys_info>();
 
     info->store = store;
@@ -3100,15 +3079,17 @@ public:
   }
 };
 
-class RGWMetadataHandlerPut_BucketInstance : public RGWMetadataHanderPut_SObj
+class RGWMetadataHandlerPut_BucketInstance : public RGWMetadataHandlerPut_SObj
 {
+  CephContext *cct;
   RGWBucketInstanceMetadataHandler *handler;
   RGWBucketInstanceMetadataObject *obj;
 public:
-  RGWMetadataHandlerPut_BucketInstance(RGWBucketInstanceMetadataHandler *_handler,
-                                       RGWSI_MetaBackend::Context *ctx, string& entry,
+  RGWMetadataHandlerPut_BucketInstance(CephContext *cct,
+                                       RGWBucketInstanceMetadataHandler *_handler,
+                                       RGWSI_MetaBackend_Handler::Op *ctx, string& entry,
                                        RGWMetadataObject *_obj, RGWObjVersionTracker& objv_tracker,
-                                       RGWMDLogSyncType type) : RGWMetadataHanderPut_SObj(ctx, entry, obj, objv_tracker, type),
+                                       RGWMDLogSyncType type) : RGWMetadataHandlerPut_SObj(_handler, op, entry, obj, objv_tracker, type),
                                                                 handler(_handler) {
     obj = static_cast<RGWBucketInstanceMetadataObject *>(_obj);
 
@@ -3117,26 +3098,28 @@ public:
   }
 
   void encode_obj(bufferlist *bl) override {
-    ceph::encode(obj->get_bucket_info(), *bl);
+    obj->get_bucket_info().encode(*bl);
   }
 
   int put_pre() override;
   int put_post() override;
 };
 
-int RGWBucketInstanceMetadatHandler::do_put(RGWSI_MetaBackend::Context *ctx, string& entry,
+int RGWBucketInstanceMetadataHandler::do_put(RGWSI_MetaBackend::Context *ctx, string& entry,
                                             RGWMetadataObject *obj,
                                             RGWObjVersionTracker& objv_tracker,
                                             optional_yield y,
-                                            RGWMDLogSyncType type) override
+                                            RGWMDLogSyncType type)
 {
-  RGWMetadataHandlerPut_BucketInstance put_op(this, ctx, entry, obj,
+  RGWMetadataHandlerPut_BucketInstance put_op(svc.bucket->ctx(), this, ctx, entry, obj,
                                               objv_tracker, y, type);
-  return do_put(&op);
+  return do_put_operate(&op);
 }
 
 int RGWMetadataHandlerPut_BucketInstance::put_pre()
 {
+  int ret;
+
   RGWBucketCompleteInfo& bci = obj->get_bci();
 
   RGWBucketInstanceMetadataObject *old_obj = static_cast<RGWBucketInstanceMetadataObject *>(_old_obj);
@@ -3145,7 +3128,7 @@ int RGWMetadataHandlerPut_BucketInstance::put_pre()
 
   bool exists = (!!old_obj);
 
-  if (!exists || old_bci->info.bucket.bucket_id != bci->info.bucket.bucket_id) {
+  if (!exists || old_bci->info.bucket.bucket_id != bci.info.bucket.bucket_id) {
     /* a new bucket, we need to select a new bucket placement for it */
     auto key(entry);
     rgw_bucket_instance_oid_to_key(key);
@@ -3177,13 +3160,13 @@ int RGWMetadataHandlerPut_BucketInstance::put_pre()
     if (!bci.info.datasync_flag_enabled()) {
       ret = store->stop_bi_log_entries(bci.info, -1);
       if (ret < 0) {
-        lderr(store->ctx()) << "ERROR: failed writing bilog" << dendl;
+        lderr(cct) << "ERROR: failed writing bilog" << dendl;
         return ret;
       }
     } else {
       ret = store->resync_bi_log_entries(bci.info, -1);
       if (ret < 0) {
-        lderr(store->ctx()) << "ERROR: failed writing bilog" << dendl;
+        lderr(cct) << "ERROR: failed writing bilog" << dendl;
         return ret;
       }
     }
@@ -3191,7 +3174,7 @@ int RGWMetadataHandlerPut_BucketInstance::put_pre()
     for (int i = 0; i < shards_num; ++i, ++shard_id) {
       ret = store->data_log->add_entry(bci.info.bucket, shard_id);
       if (ret < 0) {
-        lderr(store->ctx()) << "ERROR: failed writing data log" << dendl;
+        lderr(cct) << "ERROR: failed writing data log" << dendl;
         return ret;
       }
     }
@@ -3208,7 +3191,7 @@ int RGWMetadataHandlerPut_BucketInstance::put_post()
 {
   objv_tracker = bci.info.objv_tracker;
 
-  ret = store->init_bucket_index(bci.info, bci.info.num_shards);
+  int ret = store->init_bucket_index(bci.info, bci.info.num_shards);
   if (ret < 0)
     return ret;
 
@@ -3218,8 +3201,8 @@ int RGWMetadataHandlerPut_BucketInstance::put_post()
 class RGWArchiveBucketInstanceMetadataHandler : public RGWBucketInstanceMetadataHandler {
 public:
 
-  int do_remove(RGWSI_MetaBackend::Context *ctx, string& entry, RGWObjVersionTracker& objv_tracker) override {
-    ldout(cct, 0) << "SKIP: bucket instance removal is not allowed on archive zone: bucket.instance:" << entry << dendl;
+  int do_remove(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWObjVersionTracker& objv_tracker) override {
+    ldout(svc.bucket->ctx(), 0) << "SKIP: bucket instance removal is not allowed on archive zone: bucket.instance:" << entry << dendl;
     return 0;
   }
 };
@@ -3237,10 +3220,11 @@ RGWBucketCtl::RGWBucketCtl(RGWSI_Zone *zone_svc,
   bi_be_handler = bmi_handler->get_be_handler();
 }
 
-int RGWSI_Bucket::read_bucket_entrypoint_info(const rgw_bucket& bucket,
+int RGWBucketCtl::read_bucket_entrypoint_info(const rgw_bucket& bucket,
                                               RGWBucketEntryPoint *info,
-                                              RGWSI_Bucket::Bucket::GetParams& params)
+                                              ceph::optional_ref_default<RGWBucketCtl::Bucket::GetParams> _params)
 {
+  auto& params = *_params;
   return bucket_be_handler->call([&](RGWSI_MetaBackend_Handler::Op *op) {
     return svc.bucket->read_bucket_entrypoint_info(op->ctx(),
                                                    RGWSI_Bucket::get_entrypoint_meta_key(bucket),
@@ -3253,13 +3237,15 @@ int RGWSI_Bucket::read_bucket_entrypoint_info(const rgw_bucket& bucket,
   });
 }
 
-int RGWSI_Bucket::store_bucket_entrypoint_info(const rgw_bucket& bucket,
+int RGWBucketCtl::store_bucket_entrypoint_info(const rgw_bucket& bucket,
                                                RGWBucketEntryPoint& info,
-                                               RGWSI_Bucket::Bucket::PutParams& params)
+                                               ceph::optional_ref_default<RGWBucketCtl::Bucket::PutParams> _params)
 {
+  auto& params = *_params;
   return bucket_be_handler->call([&](RGWSI_MetaBackend_Handler::Op *op) {
     return svc.bucket->store_bucket_entrypoint_info(op->ctx(),
-                                                    bucket,
+                                                    RGWSI_Bucket::get_entrypoint_meta_key(bucket),
+                                                    info,
                                                     params.exclusive,
                                                     params.mtime,
                                                     params.attrs,
@@ -3267,20 +3253,22 @@ int RGWSI_Bucket::store_bucket_entrypoint_info(const rgw_bucket& bucket,
   });
 }
 
-int RGWSI_Bucket::remove_bucket_entrypoint_info(const rgw_bucket& bucket,
-                                                RGWSI_Bucket::Bucket::RemoveParams& params)
+int RGWBucketCtl::remove_bucket_entrypoint_info(const rgw_bucket& bucket,
+                                                ceph::optional_ref_default<RGWBucketCtl::Bucket::RemoveParams> _params)
 {
+  auto& params = *_params;
   return bucket_be_handler->call([&](RGWSI_MetaBackend_Handler::Op *op) {
     return svc.bucket->remove_bucket_entrypoint_info(op->ctx(),
-                                                     bucket,
+                                                     RGWSI_Bucket::get_entrypoint_meta_key(bucket),
                                                      params.objv_tracker);
   });
 }
 
-int RGWSI_Bucket::read_bucket_instance_info(const rgw_bucket& bucket,
+int RGWBucketCtl::read_bucket_instance_info(const rgw_bucket& bucket,
                                             RGWBucketInfo *info,
-                                            RGWSI_Bucket::BucketInstance::GetParams& params)
+                                            ceph::optional_ref_default<RGWBucketCtl::BucketInstance::GetParams> _params)
 {
+  auto& params = *_params;
   int ret = bi_be_handler->call([&](RGWSI_MetaBackend_Handler::Op *op) {
     return svc.bucket->read_bucket_instance_info(op->ctx(),
                                                  RGWSI_Bucket::get_bi_meta_key(bucket),
@@ -3296,16 +3284,17 @@ int RGWSI_Bucket::read_bucket_instance_info(const rgw_bucket& bucket,
   }
 
   if (params.objv_tracker) {
-    *params.objv_tracker = info.objv_tracker;
+    *params.objv_tracker = info->objv_tracker;
   }
 
   return 0;
 }
 
-int RGWSI_Bucket::store_bucket_instance_info(const rgw_bucket& bucket,
+int RGWBucketCtl::store_bucket_instance_info(const rgw_bucket& bucket,
                                             RGWBucketInfo& info,
-                                            RGWSI_Bucket::Bucket::PutParams& params)
+                                            ceph::optional_ref_default<RGWBucketCtl::BucketInstance::PutParams> _params)
 {
+  auto& params = *_params;
   if (params.objv_tracker) {
     info.objv_tracker = *params.objv_tracker;
   }
@@ -3320,21 +3309,44 @@ int RGWSI_Bucket::store_bucket_instance_info(const rgw_bucket& bucket,
   });
 }
 
-int RGWSI_Bucket::remove_bucket_instance_info(const rgw_bucket& bucket,
+int RGWBucketCtl::remove_bucket_instance_info(const rgw_bucket& bucket,
                                               RGWBucketInfo& info,
-                                              RGWSI_Bucket::Bucket::RemoveParams& params)
+                                              ceph::optional_ref_default<RGWBucketCtl::BucketInstance::RemoveParams> _params)
 {
+  auto& params = *_params;
   if (params.objv_tracker) {
     info.objv_tracker = *params.objv_tracker;
   }
 
   return bi_be_handler->call([&](RGWSI_MetaBackend_Handler::Op *op) {
     return svc.bucket->remove_bucket_instance_info(op->ctx(),
-                                                   RGWSI_Bucket::get_bi_meta_key(bucket),
+                                                   RGWBucketCtl::get_bi_meta_key(bucket),
                                                    &info.objv_tracker));
   });
 }
 
+int RGWBucketCtl::set_bucket_instance_attrs(RGWBucketInfo& bucket_info,
+                                            map<string, bufferlist>& attrs,
+                                            RGWObjVersionTracker *objv_tracker)
+{
+  rgw_bucket& bucket = bucket_info.bucket;
+
+  if (!bucket_info.has_instance_obj) {
+    /* an old bucket object, need to convert it */
+    RGWSysObjectCtx obj_ctx = store->svc.sysobj->init_obj_ctx();
+    int ret = convert_old_bucket_info(store, obj_ctx, bucket.tenant, bucket.name);
+    if (ret < 0) {
+      ldout(store->ctx(), 0) << "ERROR: failed converting old bucket info: " << ret << dendl;
+      return ret;
+    }
+  }
+
+  return store_bucket_instance_info(bucket,
+                                    bucket_info,
+                                    PutParams().set_attrs(&attrs)
+                                               .set_objv_tracker(objv_tracker));
+}
+
 
 RGWMetadataHandler *RGWBucketMetaHandlerAllocator::alloc() {
   return new RGWBucketMetadataHandler;

diff --git a/src/rgw/rgw_bucket.h b/src/rgw/rgw_bucket.h
index 2b6131aef0652d9891aaa868e03941e072dee586..69f3dc2f88394e8b8d023b6a870db0d6161f9c2d 100644 (file)
--- a/src/rgw/rgw_bucket.h
+++ b/src/rgw/rgw_bucket.h
@@ -19,9 +19,13 @@
 #include "common/Formatter.h"
 #include "common/lru_map.h"
 #include "common/ceph_time.h"
+#include "common/optional_ref_default.h"
+
 #include "rgw_formats.h"
 
 class RGWSI_Meta;
+class RGWBucketMetadataHandler;
+class RGWBucketInstanceMetadataHandler;
 
 extern int rgw_bucket_parse_bucket_instance(const string& bucket_instance, string *target_bucket_instance, int *shard_id);
 extern int rgw_bucket_parse_bucket_key(CephContext *cct, const string& key,
@@ -57,7 +61,12 @@ class RGWBucketEntryMetadataObject : public RGWMetadataObject {
   RGWBucketEntryPoint ep;
   map<string, bufferlist> attrs;
 public:
-  RGWBucketEntryMetadataObject(RGWBucketEntryPoint& _ep, obj_version& v, real_time m, std::map<string, bufferlist>&& _attrs) :
+  RGWBucketEntryMetadataObject(RGWBucketEntryPoint& _ep, const obj_version& v, real_time m) : ep(_ep) {
+    objv = v;
+    mtime = m;
+    set_pattrs (&attrs);
+  }
+  RGWBucketEntryMetadataObject(RGWBucketEntryPoint& _ep, const obj_version& v, real_time m, std::map<string, bufferlist>&& _attrs) :
     ep(_ep), attrs(std::move(_attrs)) {
     objv = v;
     mtime = m;
@@ -94,7 +103,12 @@ public:
     info.decode_json(obj);
   }
 
-  RGWBucketInfo& get_bucket_info() { return info.info; }
+  RGWBucketCompleteInfo& get_bci() {
+    return info;
+  }
+  RGWBucketInfo& get_bucket_info() {
+    return info.info;
+  }
 };
 
 /**
@@ -688,33 +702,33 @@ public:
         return *this;
       }
     };
-  };
 
-  struct PutParams {
-    ceph::real_time mtime;
-    bool exclusive{false};
-    map<string, bufferlist> *attrs{nullptr};
-    RGWObjVersionTracker *objv_tracker{nullptr};
+    struct PutParams {
+      ceph::real_time mtime;
+      bool exclusive{false};
+      map<string, bufferlist> *attrs{nullptr};
+      RGWObjVersionTracker *objv_tracker{nullptr};
 
-    PutParams& set_mtime(const ceph::real_time& _mtime) {
-      mtime = _mtime;
-      return *this;
-    }
+      PutParams& set_mtime(const ceph::real_time& _mtime) {
+        mtime = _mtime;
+        return *this;
+      }
 
-    PutParams& set_exclusive(bool _exclusive) {
-      exclusive = _exclusive;
-      return *this;
-    }
+      PutParams& set_exclusive(bool _exclusive) {
+        exclusive = _exclusive;
+        return *this;
+      }
 
-    PutParams& set_attrs(map<string, bufferlist> *_attrs) {
-      attrs = _attrs;
-      return *this;
-    }
+      PutParams& set_attrs(map<string, bufferlist> *_attrs) {
+        attrs = _attrs;
+        return *this;
+      }
 
-    RemoveParams& set_objv_tracker(RGWObjVersionTracker *_objv_tracker) {
-      objv_tracker = _objv_tracker;
-      return *this;
-    }
+      PutParams& set_objv_tracker(RGWObjVersionTracker *_objv_tracker) {
+        objv_tracker = _objv_tracker;
+        return *this;
+      }
+    };
 
     struct RemoveParams {
       RGWObjVersionTracker *objv_tracker{nullptr};
@@ -729,22 +743,23 @@ public:
   /* bucket entrypoint */
   int read_bucket_entrypoint_info(const rgw_bucket& bucket,
                                   RGWBucketEntryPoint *info,
-                                  RGWSI_Bucket::Bucket::GetParams& params);
+                                  ceph::optional_ref_default<RGWBucketCtl::Bucket::GetParams> params);
   int store_bucket_entrypoint_info(const rgw_bucket& bucket,
                                    RGWBucketEntryPoint& info,
-                                   RGWSI_Bucket::Bucket::PutParams& params);
+                                   ceph::optional_ref_default<RGWBucketCtl::Bucket::PutParams> params);
   int remove_bucket_entrypoint_info(const rgw_bucket& bucket,
-                                    RGWSI_Bucket::Bucket::RemoveParams& params);
+                                    ceph::optional_ref_default<RGWBucketCtl::Bucket::RemoveParams> params);
 
   /* bucket instance */
   int read_bucket_instance_info(const rgw_bucket& bucket,
                                   RGWBucketInfo *info,
-                                  RGWSI_Bucket::BucketInstance::GetParams& params);
+                                  ceph::optional_ref_default<RGWBucketCtl::BucketInstance::GetParams> params);
   int store_bucket_instance_info(const rgw_bucket& bucket,
                                    RGWBucketInfo& info,
-                                   RGWSI_Bucket::BucketInstance::PutParams& params);
+                                   ceph::optional_ref_default<RGWBucketCtl::BucketInstance::PutParams> params);
   int remove_bucket_instance_info(const rgw_bucket& bucket,
-                                    RGWSI_Bucket::BucketInstance::RemoveParams& params);
+                                  RGWBucketInfo& info,
+                                  ceph::optional_ref_default<RGWBucketCtl::BucketInstance::RemoveParams> params);
 };
 
 

diff --git a/src/rgw/rgw_service.h b/src/rgw/rgw_service.h
index c4f656219077e463580e1a0efc6a350214684837..b503ac133cd30e5f0a494d699e71dbb27e9a8f21 100644 (file)
--- a/src/rgw/rgw_service.h
+++ b/src/rgw/rgw_service.h
@@ -150,7 +150,7 @@ struct RGWCtlDef {
   } meta;
 
   std::unique_ptr<RGWUserCtl> user;
-  std::unique_ptr<RGWBucketCtl> user;
+  std::unique_ptr<RGWBucketCtl> bucket;
 
   RGWCtlDef();
   ~RGWCtlDef();
@@ -171,7 +171,7 @@ struct RGWCtl {
   } meta;
 
   RGWUserCtl *user{nullptr};
-  RGWBucketCtl *user{nullptr};
+  RGWBucketCtl *bucket{nullptr};
 
   int init(RGWServices& svc);
 };

diff --git a/src/rgw/services/svc_bucket.h b/src/rgw/services/svc_bucket.h
index 247213ed37a7bfa07630760553306ceb406f4890..e3f66b3bf9af690ae259aa526c4b84918f40cb03 100644 (file)
--- a/src/rgw/services/svc_bucket.h
+++ b/src/rgw/services/svc_bucket.h
@@ -76,6 +76,14 @@ public:
   static string get_entrypoint_meta_key(const rgw_bucket& bucket);
   static string get_bi_meta_key(const rgw_bucket& bucket);
 
+  RGWSI_MetaBackend_Handler *get_ep_be_handler() {
+    return ep_be_handler;
+  }
+
+  RGWSI_MetaBackend_Handler *get_bi_be_handler() {
+    return bi_be_handler;
+  }
+
   void init(RGWSI_Zone *_zone_svc, RGWSI_SysObj *_sysobj_svc,
            RGWSI_SysObj_Cache *_cache_svc, RGWSI_Meta *_meta_svc,
             RGWSI_MetaBackend *_meta_be_svc,

diff --git a/src/rgw/services/svc_user.cc b/src/rgw/services/svc_user.cc
index b130a87cb3b38e3fbd104a59eb6a50ea69c5d0d4..2697c83af8d64b40339ff37fe676b2b98de54891 100644 (file)
--- a/src/rgw/services/svc_user.cc
+++ b/src/rgw/services/svc_user.cc
@@ -110,7 +110,7 @@ class PutOperation
   const RGWUserInfo& info;
   RGWUserInfo *old_info;
   RGWObjVersionTracker *objv_tracker;
-  real_time& mtime;
+  const real_time& mtime;
   bool exclusive;
   map<string, bufferlist> *pattrs;
   RGWObjVersionTracker ot;
@@ -129,7 +129,7 @@ public:
                const RGWUserInfo& info,
                RGWUserInfo *old_info,
                RGWObjVersionTracker *objv_tracker,
-               real_time& mtime,
+               const real_time& mtime,
                bool exclusive,
                map<string, bufferlist> *pattrs,
                optional_yield _y) :
@@ -297,7 +297,7 @@ int RGWSI_User::store_user_info(RGWSI_MetaBackend::Context *ctx,
                                 const RGWUserInfo& info,
                                 RGWUserInfo *old_info,
                                 RGWObjVersionTracker *objv_tracker,
-                                real_time& mtime,
+                                const real_time& mtime,
                                 bool exclusive,
                                 map<string, bufferlist> *attrs,
                                 optional_yield y)

diff --git a/src/rgw/services/svc_user.h b/src/rgw/services/svc_user.h
index e877b62b7f854c31719425da2b0499049396d885..99f4ed5268e46add441b7d75fcc0ec4b75b90063 100644 (file)
--- a/src/rgw/services/svc_user.h
+++ b/src/rgw/services/svc_user.h
@@ -114,7 +114,7 @@ public:
                       const RGWUserInfo& info,
                       RGWUserInfo *old_info,
                       RGWObjVersionTracker *objv_tracker,
-                      real_time& mtime,
+                      const real_time& mtime,
                       bool exclusive,
                       map<string, bufferlist> *attrs,
                       optional_yield y);