rgw: switch RGWRados::delete_obj() to new interface

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

diff --git a/src/rgw/rgw_bucket.cc b/src/rgw/rgw_bucket.cc
index 7d649ad751494a2b178c6c7d5da89819f8a8de4d..fd7b075aeed75d3334e48f66c14d614d80f8355d 100644 (file)
--- a/src/rgw/rgw_bucket.cc
+++ b/src/rgw/rgw_bucket.cc
@@ -343,7 +343,7 @@ int rgw_remove_object(RGWRados *store, const string& bucket_owner, rgw_bucket& b
 
   rgw_obj obj(bucket, key);
 
-  int ret = store->delete_obj((void *)&rctx, bucket_owner, obj, use_versioning);
+  int ret = store->delete_obj(rctx, bucket_owner, obj, use_versioning);
 
   return ret;
 }

diff --git a/src/rgw/rgw_metadata.cc b/src/rgw/rgw_metadata.cc
index fb96b506c0f5727f32b57a71af35448fe8df3964..ece9ebf224e47ce1340f99bf1a1b42d4e1e64606 100644 (file)
--- a/src/rgw/rgw_metadata.cc
+++ b/src/rgw/rgw_metadata.cc
@@ -601,7 +601,7 @@ int RGWMetadataManager::remove_entry(RGWMetadataHandler *handler, string& key, R
 
   rgw_obj obj(bucket, oid);
 
-  ret = store->delete_system_obj(NULL, obj, objv_tracker);
+  ret = store->delete_system_obj(obj, objv_tracker);
   /* cascading ret into post_modify() */
 
   ret = post_modify(handler, section, key, log_data, objv_tracker, ret);

diff --git a/src/rgw/rgw_op.cc b/src/rgw/rgw_op.cc
index 60cd7e7e31153d4c057cb3b682bcd8245fbc4794..bc4995490a2407789cc23c6c721811933540ea84 100644 (file)
--- a/src/rgw/rgw_op.cc
+++ b/src/rgw/rgw_op.cc
@@ -2078,8 +2078,11 @@ void RGWDeleteObj::execute()
   ret = -EINVAL;
   rgw_obj obj(s->bucket, s->object);
   if (!s->object.empty()) {
-    store->set_atomic(s->obj_ctx, obj);
-    ret = store->delete_obj(s->obj_ctx, s->bucket_owner.get_id(), obj, s->bucket_info.versioning_enabled());
+    RGWRados::ObjectCtx *obj_ctx = (RGWRados::ObjectCtx *)s->obj_ctx;
+
+    obj_ctx->set_atomic(obj);
+
+    ret = store->delete_obj(*obj_ctx, s->bucket_owner.get_id(), obj, s->bucket_info.versioning_enabled());
   }
 }
 
@@ -2925,7 +2928,10 @@ void RGWCompleteMultipart::execute()
   }
 
   // remove the upload obj
-  store->delete_obj(&obj_ctx, s->bucket_owner.get_id(), meta_obj, false);
+  int r = store->delete_obj(*(RGWRados::ObjectCtx *)s->obj_ctx, s->bucket_owner.get_id(), meta_obj, false);
+  if (r < 0) {
+    ldout(store->ctx(), 0) << "WARNING: failed to remove object " << meta_obj << dendl;
+  }
 }
 
 int RGWAbortMultipart::verify_permission()
@@ -2968,6 +2974,8 @@ void RGWAbortMultipart::execute()
   int marker = 0;
   int max_parts = 1000;
 
+  RGWRados::ObjectCtx *obj_ctx = (RGWRados::ObjectCtx *)s->obj_ctx;
+
   do {
     ret = list_multipart_parts(store, s, upload_id, meta_oid, max_parts, marker, obj_parts, &marker, &truncated);
     if (ret < 0)
@@ -2980,7 +2988,7 @@ void RGWAbortMultipart::execute()
         string oid = mp.get_part(obj_iter->second.num);
         rgw_obj obj;
         obj.init_ns(s->bucket, oid, mp_ns);
-        ret = store->delete_obj(s->obj_ctx, owner, obj, false);
+        ret = store->delete_obj(*obj_ctx, owner, obj, false);
         if (ret < 0 && ret != -ENOENT)
           return;
       } else {
@@ -2988,7 +2996,7 @@ void RGWAbortMultipart::execute()
         RGWObjManifest::obj_iterator oiter;
         for (oiter = manifest.obj_begin(); oiter != manifest.obj_end(); ++oiter) {
           rgw_obj loc = oiter.get_location();
-          ret = store->delete_obj(s->obj_ctx, owner, loc, false);
+          ret = store->delete_obj(*obj_ctx, owner, loc, false);
           if (ret < 0 && ret != -ENOENT)
             return;
         }
@@ -2999,7 +3007,7 @@ void RGWAbortMultipart::execute()
   // and also remove the metadata obj
   meta_obj.init_ns(s->bucket, meta_oid, mp_ns);
   meta_obj.set_in_extra_data(true);
-  ret = store->delete_obj(s->obj_ctx, owner, meta_obj, false);
+  ret = store->delete_obj(*obj_ctx, owner, meta_obj, false);
   if (ret == -ENOENT) {
     ret = -ERR_NO_SUCH_BUCKET;
   }
@@ -3109,6 +3117,7 @@ void RGWDeleteMultiObj::execute()
   RGWMultiDelXMLParser parser;
   pair<string,int> result;
   int num_processed = 0;
+  RGWRados::ObjectCtx *obj_ctx = (RGWRados::ObjectCtx *)s->obj_ctx;
 
   ret = get_params();
   if (ret < 0) {
@@ -3149,8 +3158,9 @@ void RGWDeleteMultiObj::execute()
         ++iter, num_processed++) {
 
     rgw_obj obj(bucket,(*iter));
-    store->set_atomic(s->obj_ctx, obj);
-    ret = store->delete_obj(s->obj_ctx, s->bucket_owner.get_id(), obj, s->bucket_info.versioning_enabled());
+
+    obj_ctx->set_atomic(obj);
+    ret = store->delete_obj(*obj_ctx, s->bucket_owner.get_id(), obj, s->bucket_info.versioning_enabled());
     if (ret == -ENOENT) {
       ret = 0;
     }

diff --git a/src/rgw/rgw_rados.cc b/src/rgw/rgw_rados.cc
index aca79a12ddebe06e35fcfa6d5d8f788d1693956c..e563ee790236e36adf3866c2142b149e4f8e29ea 100644 (file)
--- a/src/rgw/rgw_rados.cc
+++ b/src/rgw/rgw_rados.cc
@@ -893,7 +893,7 @@ RGWPutObjProcessor_Aio::~RGWPutObjProcessor_Aio()
   list<rgw_obj>::iterator iter;
   for (iter = written_objs.begin(); iter != written_objs.end(); ++iter) {
     rgw_obj& obj = *iter;
-    int r = store->delete_obj(&obj_ctx, bucket_owner, obj, false);
+    int r = store->delete_obj(obj_ctx, bucket_owner, obj, false);
     if (r < 0 && r != -ENOENT) {
       ldout(store->ctx(), 0) << "WARNING: failed to remove obj (" << obj << "), leaked" << dendl;
     }
@@ -3909,26 +3909,32 @@ void RGWRados::remove_rgw_head_obj(ObjectWriteOperation& op)
  * obj: name of the object to delete
  * Returns: 0 on success, -ERR# otherwise.
  */
-int RGWRados::delete_obj_impl(void *ctx, const string& bucket_owner, rgw_obj& obj, bool use_versioning, RGWObjVersionTracker *objv_tracker)
+int RGWRados::Object::Delete::delete_obj()
 {
+  RGWRados *store = target->get_store();
+  rgw_obj& obj = target->get_obj();
+
   rgw_rados_ref ref;
   rgw_bucket bucket;
-  int r = get_obj_ref(obj, &ref, &bucket);
+  int r = store->get_obj_ref(obj, &ref, &bucket);
   if (r < 0) {
     return r;
   }
-  ObjectCtx *rctx = static_cast<ObjectCtx *>(ctx);
 
   ObjectWriteOperation op;
 
+  r = target->prepare_atomic_modification(op, false, NULL);
+  if (r < 0)
+    return r;
+
   RGWObjState *state;
-  r = prepare_atomic_for_write(rctx, obj, op, &state, false, NULL);
+  r = target->get_state(&state);
   if (r < 0)
     return r;
 
-  bool ret_not_existed = (state && !state->exists);
+  bool ret_not_existed = (!state->exists);
 
-  RGWRados::Bucket bop(this, bucket);
+  RGWRados::Bucket bop(store, bucket);
   RGWRados::Bucket::UpdateIndex index_op(&bop, obj, state);
 
   string tag;
@@ -3936,12 +3942,12 @@ int RGWRados::delete_obj_impl(void *ctx, const string& bucket_owner, rgw_obj& ob
   if (r < 0)
     return r;
 
-  if (objv_tracker) {
-    objv_tracker->prepare_op_for_write(&op);
-  }
-
-  remove_rgw_head_obj(op);
+  store->remove_rgw_head_obj(op);
   r = ref.ioctx.operate(ref.oid, &op);
+  if (r == -ECANCELED) {
+    /* raced with another operation, we can regard it as removed */
+    r = 0;
+  }
   bool removed = (r >= 0);
 
   int64_t poolid = ref.ioctx.get_id();
@@ -3950,28 +3956,28 @@ int RGWRados::delete_obj_impl(void *ctx, const string& bucket_owner, rgw_obj& ob
   } else {
     int ret = index_op.cancel();
     if (ret < 0) {
-      ldout(cct, 0) << "ERROR: index_op.cancel() returned ret=" << ret << dendl;
+      ldout(store->ctx(), 0) << "ERROR: index_op.cancel() returned ret=" << ret << dendl;
     }
   }
   if (removed) {
-    int ret = index_op.complete_atomic_modification();
+    int ret = target->complete_atomic_modification();
     if (ret < 0) {
-      ldout(cct, 0) << "ERROR: complete_atomic_removal returned ret=" << ret << dendl;
+      ldout(store->ctx(), 0) << "ERROR: complete_atomic_modification returned ret=" << ret << dendl;
     }
     /* other than that, no need to propagate error */
   }
 
-  atomic_write_finish(state, r);
+  store->atomic_write_finish(state, r);
 
   if (r < 0)
     return r;
 
   /* need to insert a delete marker? */
-  if (use_versioning && obj.get_instance().empty()) {
+  if (params.use_versioning && obj.get_instance().empty()) {
     rgw_obj marker = obj;
-    gen_rand_obj_instance_name(&marker);
+    store->gen_rand_obj_instance_name(&marker);
 
-    r = set_olh(*rctx, bucket_owner, marker, true);
+    r = store->set_olh(target->get_ctx(), params.bucket_owner, marker, true);
     if (r < 0) {
       return r;
     }
@@ -3982,33 +3988,44 @@ int RGWRados::delete_obj_impl(void *ctx, const string& bucket_owner, rgw_obj& ob
 
   if (state) {
     /* update quota cache */
-    quota_handler->update_stats(bucket_owner, bucket, -1, 0, state->size);
+    store->quota_handler->update_stats(params.bucket_owner, bucket, -1, 0, state->size);
   }
 
   return 0;
 }
 
-int RGWRados::delete_obj(void *ctx, const string& bucket_owner, rgw_obj& obj, bool use_versioning, RGWObjVersionTracker *objv_tracker)
+int RGWRados::delete_obj(RGWRados::ObjectCtx& obj_ctx, const string& bucket_owner, rgw_obj& obj, bool use_versioning)
 {
-  int r;
+  RGWRados::Object del_target(this, obj_ctx, obj);
+  RGWRados::Object::Delete del_op(&del_target);
 
-  r = delete_obj_impl(ctx, bucket_owner, obj, use_versioning, objv_tracker);
-  if (r == -ECANCELED)
-    r = 0;
+  del_op.params.bucket_owner = bucket_owner;
+  del_op.params.use_versioning = use_versioning;
 
-  return r;
+  return del_op.delete_obj();
 }
 
-int RGWRados::delete_system_obj(void *ctx, rgw_obj& obj, RGWObjVersionTracker *objv_tracker)
+int RGWRados::delete_system_obj(rgw_obj& obj, RGWObjVersionTracker *objv_tracker)
 {
-  int r;
+  rgw_rados_ref ref;
+  rgw_bucket bucket;
+  int r = get_obj_ref(obj, &ref, &bucket);
+  if (r < 0) {
+    return r;
+  }
 
-  string no_owner;
-  r = delete_obj_impl(ctx, no_owner, obj, false, objv_tracker);
-  if (r == -ECANCELED)
-    r = 0;
+  ObjectWriteOperation op;
 
-  return r;
+  if (objv_tracker) {
+    objv_tracker->prepare_op_for_write(&op);
+  }
+
+  remove_rgw_head_obj(op);
+  r = ref.ioctx.operate(ref.oid, &op);
+  if (r < 0)
+    return r;
+
+  return 0;
 }
 
 int RGWRados::delete_obj_index(rgw_obj& obj)
@@ -5660,7 +5677,7 @@ int RGWRados::apply_olh_log(ObjectCtx& obj_ctx, const string& bucket_owner, rgw_
     cls_rgw_obj_key& key = *liter;
     rgw_obj obj_instance(bucket, key.name);
     obj_instance.set_instance(key.instance);
-    int ret = delete_obj(&obj_ctx, bucket_owner, obj_instance, false);
+    int ret = delete_obj(obj_ctx, bucket_owner, obj_instance, false);
     if (ret < 0 && ret != -ENOENT) {
       ldout(cct, 0) << "ERROR: delete_obj() returned " << ret << " obj_instance=" << obj_instance << dendl;
       return ret;
@@ -7288,6 +7305,7 @@ int RGWRados::process_intent_log(rgw_bucket& bucket, string& oid,
     }
     
     struct rgw_intent_log_entry entry;
+    RGWRados::ObjectCtx obj_ctx(this);
     try {
       ::decode(entry, iter);
     } catch (buffer::error& err) {
@@ -7309,7 +7327,7 @@ int RGWRados::process_intent_log(rgw_bucket& bucket, string& oid,
         complete = false;
         break;
       }
-      r = delete_obj(NULL, no_owner, entry.obj, false);
+      r = delete_obj(obj_ctx, no_owner, entry.obj, false);
       if (r < 0 && r != -ENOENT) {
         cerr << "failed to remove obj: " << entry.obj << std::endl;
         complete = false;
@@ -7346,7 +7364,7 @@ int RGWRados::process_intent_log(rgw_bucket& bucket, string& oid,
     rgw_obj obj(bucket, oid);
     cout << "completed intent log: " << obj << (purge ? ", purging it" : "") << std::endl;
     if (purge) {
-      r = delete_system_obj(NULL, obj);
+      r = delete_system_obj(obj);
       if (r < 0)
         cerr << "failed to remove obj: " << obj << std::endl;
     }

diff --git a/src/rgw/rgw_rados.h b/src/rgw/rgw_rados.h
index 02728d8b53936546fe32a3fe980dae254e3ac015..4bfb6fa75f4735b6d9bd79d372f640022ce1a4c2 100644 (file)
--- a/src/rgw/rgw_rados.h
+++ b/src/rgw/rgw_rados.h
@@ -1218,8 +1218,6 @@ private:
 
   void remove_rgw_head_obj(librados::ObjectWriteOperation& op);
 protected:
-  virtual int delete_obj_impl(void *ctx, const string& bucket_owner, rgw_obj& src_obj, bool use_versioning, RGWObjVersionTracker *objv_tracker);
-
   CephContext *cct;
   librados::Rados *rados;
   librados::IoCtx gc_pool_ctx;        // .rgw.gc
@@ -1393,6 +1391,7 @@ public:
 
     RGWRados *get_store() { return store; }
     rgw_obj& get_obj() { return obj; }
+    RGWRados::ObjectCtx& get_ctx() { return ctx; }
 
     struct Write {
       RGWRados::Object *target;
@@ -1421,6 +1420,21 @@ public:
       int write_meta(uint64_t size,  map<std::string, bufferlist>& attrs);
       int write_data(const char *data, uint64_t ofs, uint64_t len, bool exclusive);
     };
+
+    struct Delete {
+      RGWRados::Object *target;
+
+      struct DeleteParams {
+        string bucket_owner;
+        bool use_versioning;
+
+        DeleteParams() : use_versioning(false) {}
+      } params;
+      
+      Delete(RGWRados::Object *_target) : target(_target) {}
+
+      int delete_obj();
+    };
   };
 
   class Bucket {
@@ -1537,8 +1551,10 @@ public:
   int bucket_suspended(rgw_bucket& bucket, bool *suspended);
 
   /** Delete an object.*/
-  virtual int delete_obj(void *ctx, const string& bucket_owner, rgw_obj& src_obj, bool use_versioning, RGWObjVersionTracker *objv_tracker = NULL);
-  virtual int delete_system_obj(void *ctx, rgw_obj& src_obj, RGWObjVersionTracker *objv_tracker = NULL);
+  virtual int delete_obj(RGWRados::ObjectCtx& obj_ctx, const string& bucket_owner, rgw_obj& src_obj, bool use_versioning);
+
+  /* Delete a system object */
+  virtual int delete_system_obj(rgw_obj& src_obj, RGWObjVersionTracker *objv_tracker = NULL);
 
   /** Remove an object from the bucket index */
   int delete_obj_index(rgw_obj& obj);

diff --git a/src/rgw/rgw_user.cc b/src/rgw/rgw_user.cc
index e125def0cde6b3715449011f38d694f6b8784b97..40628c7b8de049e416bf31b0760e4cb87711cb36 100644 (file)
--- a/src/rgw/rgw_user.cc
+++ b/src/rgw/rgw_user.cc
@@ -318,7 +318,7 @@ extern int rgw_get_user_info_by_access_key(RGWRados *store, string& access_key,
 int rgw_remove_key_index(RGWRados *store, RGWAccessKey& access_key)
 {
   rgw_obj obj(store->zone.user_keys_pool, access_key.id);
-  int ret = store->delete_system_obj(NULL, obj);
+  int ret = store->delete_system_obj(obj);
   return ret;
 }
 
@@ -340,14 +340,14 @@ int rgw_remove_uid_index(RGWRados *store, string& uid)
 int rgw_remove_email_index(RGWRados *store, string& email)
 {
   rgw_obj obj(store->zone.user_email_pool, email);
-  int ret = store->delete_system_obj(NULL, obj);
+  int ret = store->delete_system_obj(obj);
   return ret;
 }
 
 int rgw_remove_swift_name_index(RGWRados *store, string& swift_name)
 {
   rgw_obj obj(store->zone.user_swift_pool, swift_name);
-  int ret = store->delete_system_obj(NULL, obj);
+  int ret = store->delete_system_obj(obj);
   return ret;
 }
 
@@ -409,7 +409,7 @@ int rgw_delete_user(RGWRados *store, RGWUserInfo& info, RGWObjVersionTracker& ob
 
   rgw_obj email_obj(store->zone.user_email_pool, info.user_email);
   ldout(store->ctx(), 10) << "removing email index: " << info.user_email << dendl;
-  ret = store->delete_system_obj(NULL, email_obj);
+  ret = store->delete_system_obj(email_obj);
   if (ret < 0 && ret != -ENOENT) {
     ldout(store->ctx(), 0) << "ERROR: could not remove " << info.user_id << ":" << email_obj << ", should be fixed (err=" << ret << ")" << dendl;
     return ret;
@@ -419,7 +419,7 @@ int rgw_delete_user(RGWRados *store, RGWUserInfo& info, RGWObjVersionTracker& ob
   rgw_get_buckets_obj(info.user_id, buckets_obj_id);
   rgw_obj uid_bucks(store->zone.user_uid_pool, buckets_obj_id);
   ldout(store->ctx(), 10) << "removing user buckets index" << dendl;
-  ret = store->delete_system_obj(NULL, uid_bucks);
+  ret = store->delete_system_obj(uid_bucks);
   if (ret < 0 && ret != -ENOENT) {
     ldout(store->ctx(), 0) << "ERROR: could not remove " << info.user_id << ":" << uid_bucks << ", should be fixed (err=" << ret << ")" << dendl;
     return ret;