Zipper - WriteOp

Add WriteOp to the Zipper API, and use it.

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

diff --git a/src/rgw/rgw_cr_rados.cc b/src/rgw/rgw_cr_rados.cc
index a269af767a3d1485e577fa5218d3ee21d5501dcb..38217e1854c40edb20fd0c3758d11b3b3930fb88 100644 (file)
--- a/src/rgw/rgw_cr_rados.cc
+++ b/src/rgw/rgw_cr_rados.cc
@@ -635,7 +635,7 @@ int RGWAsyncFetchRemoteObj::_send_request()
 
   char buf[16];
   snprintf(buf, sizeof(buf), ".%lld", (long long)store->getRados()->instance_id());
-  map<string, bufferlist> attrs;
+  rgw::sal::RGWAttrs attrs;
 
   rgw::sal::RGWRadosBucket bucket(store, src_bucket);
   rgw::sal::RGWRadosObject src_obj(store, key, &bucket);

diff --git a/src/rgw/rgw_op.cc b/src/rgw/rgw_op.cc
index b7765c9deae1e85232756b283e5ec93d729ee5c2..519fd1109d0d2df8b5a30c2f174fc6fa6ff68933 100644 (file)
--- a/src/rgw/rgw_op.cc
+++ b/src/rgw/rgw_op.cc
@@ -5823,8 +5823,7 @@ void RGWInitMultipart::pre_exec()
 void RGWInitMultipart::execute(optional_yield y)
 {
   bufferlist aclbl;
-  map<string, bufferlist> attrs;
-  rgw_obj obj;
+  rgw::sal::RGWAttrs attrs;
 
   if (get_params(y) < 0)
     return;
@@ -5857,6 +5856,7 @@ void RGWInitMultipart::execute(optional_yield y)
 
   do {
     char buf[33];
+    std::unique_ptr<rgw::sal::RGWObject> obj;
     gen_rand_alphanumeric(s->cct, buf, sizeof(buf) - 1);
     upload_id = MULTIPART_UPLOAD_ID_PREFIX; /* v2 upload id */
     upload_id.append(buf);
@@ -5865,29 +5865,30 @@ void RGWInitMultipart::execute(optional_yield y)
     RGWMPObj mp(s->object->get_name(), upload_id);
     tmp_obj_name = mp.get_meta();
 
-    obj.init_ns(s->bucket->get_key(), tmp_obj_name, mp_ns);
+    obj = s->bucket->get_object(rgw_obj_key(tmp_obj_name, string(), mp_ns));
     // the meta object will be indexed with 0 size, we c
-    obj.set_in_extra_data(true);
-    obj.index_hash_source = s->object->get_name();
+    obj->set_in_extra_data(true);
+    obj->set_hash_source(s->object->get_name());
 
-    RGWRados::Object op_target(store->getRados(), s->bucket->get_info(), *static_cast<RGWObjectCtx *>(s->obj_ctx), obj);
-    op_target.set_versioning_disabled(true); /* no versioning for multipart meta */
+    std::unique_ptr<rgw::sal::RGWObject::WriteOp> obj_op = obj->get_write_op(s->obj_ctx);
 
-    RGWRados::Object::Write obj_op(&op_target);
-
-    obj_op.meta.owner = s->owner.get_id();
-    obj_op.meta.category = RGWObjCategory::MultiMeta;
-    obj_op.meta.flags = PUT_OBJ_CREATE_EXCL;
-    obj_op.meta.mtime = &mtime;
+    obj_op->params.versioning_disabled = true; /* no versioning for multipart meta */
+    obj_op->params.owner = s->owner;
+    obj_op->params.category = RGWObjCategory::MultiMeta;
+    obj_op->params.flags = PUT_OBJ_CREATE_EXCL;
+    obj_op->params.mtime = &mtime;
+    obj_op->params.attrs = &attrs;
 
     multipart_upload_info upload_info;
     upload_info.dest_placement = s->dest_placement;
 
     bufferlist bl;
     encode(upload_info, bl);
-    obj_op.meta.data = &bl;
+    obj_op->params.data = &bl;
+
+    op_ret = obj_op->prepare(s->yield);
 
-    op_ret = obj_op.write_meta(bl.length(), 0, attrs, s->yield);
+    op_ret = obj_op->write_meta(bl.length(), 0, s->yield);
   } while (op_ret == -EEXIST);
   
   // send request to notification manager
@@ -5944,14 +5945,14 @@ void RGWCompleteMultipart::execute(optional_yield y)
   string meta_oid;
   map<uint32_t, RGWUploadPartInfo> obj_parts;
   map<uint32_t, RGWUploadPartInfo>::iterator obj_iter;
-  map<string, bufferlist> attrs;
+  rgw::sal::RGWAttrs attrs;
   off_t ofs = 0;
   MD5 hash;
   char final_etag[CEPH_CRYPTO_MD5_DIGESTSIZE];
   char final_etag_str[CEPH_CRYPTO_MD5_DIGESTSIZE * 2 + 16];
   bufferlist etag_bl;
   std::unique_ptr<rgw::sal::RGWObject> meta_obj;
-  rgw_obj target_obj;
+  std::unique_ptr<rgw::sal::RGWObject> target_obj;
   RGWMPObj mp;
   RGWObjManifest manifest;
   uint64_t olh_epoch = 0;
@@ -6172,33 +6173,37 @@ void RGWCompleteMultipart::execute(optional_yield y)
     attrs[RGW_ATTR_COMPRESSION] = tmp;
   }
 
-  target_obj.init(s->bucket->get_key(), s->object->get_name());
+  target_obj = s->bucket->get_object(rgw_obj_key(s->object->get_name()));
   if (versioned_object) {
     if (!version_id.empty()) {
-      target_obj.key.set_instance(version_id);
+      target_obj->set_instance(version_id);
     } else {
-      store->getRados()->gen_rand_obj_instance_name(&target_obj);
-      version_id = target_obj.key.get_instance();
+      target_obj->gen_rand_obj_instance_name();
+      version_id = target_obj->get_instance();
     }
   }
 
   RGWObjectCtx& obj_ctx = *static_cast<RGWObjectCtx *>(s->obj_ctx);
 
-  obj_ctx.set_atomic(target_obj);
+  target_obj->set_atomic(&obj_ctx);
+
+  std::unique_ptr<rgw::sal::RGWObject::WriteOp> obj_op = target_obj->get_write_op(&obj_ctx);
 
-  RGWRados::Object op_target(store->getRados(), s->bucket->get_info(), *static_cast<RGWObjectCtx *>(s->obj_ctx), target_obj);
-  RGWRados::Object::Write obj_op(&op_target);
+  obj_op->params.manifest = &manifest;
+  obj_op->params.remove_objs = &remove_objs;
 
-  obj_op.meta.manifest = &manifest;
-  obj_op.meta.remove_objs = &remove_objs;
+  obj_op->params.ptag = &s->req_id; /* use req_id as operation tag */
+  obj_op->params.owner = s->owner;
+  obj_op->params.flags = PUT_OBJ_CREATE;
+  obj_op->params.modify_tail = true;
+  obj_op->params.completeMultipart = true;
+  obj_op->params.olh_epoch = olh_epoch;
+  obj_op->params.attrs = &attrs;
+  op_ret = obj_op->prepare(s->yield);
+  if (op_ret < 0)
+    return;
 
-  obj_op.meta.ptag = &s->req_id; /* use req_id as operation tag */
-  obj_op.meta.owner = s->owner.get_id();
-  obj_op.meta.flags = PUT_OBJ_CREATE;
-  obj_op.meta.modify_tail = true;
-  obj_op.meta.completeMultipart = true;
-  obj_op.meta.olh_epoch = olh_epoch;
-  op_ret = obj_op.write_meta(ofs, accounted_size, attrs, s->yield);
+  op_ret = obj_op->write_meta(ofs, accounted_size, s->yield);
   if (op_ret < 0)
     return;
 

diff --git a/src/rgw/rgw_op.h b/src/rgw/rgw_op.h
index cbe856172413b25fd3121ebc8db9cdf013ae75fa..46e2c109b574fe94cd7e868d7e545f1a0ef8c846 100644 (file)
--- a/src/rgw/rgw_op.h
+++ b/src/rgw/rgw_op.h
@@ -1135,7 +1135,7 @@ protected:
   std::unique_ptr <RGWObjTags> obj_tags;
   const char *dlo_manifest;
   RGWSLOInfo *slo_info;
-  map<string, bufferlist> attrs;
+  rgw::sal::RGWAttrs attrs;
   ceph::real_time mtime;
   uint64_t olh_epoch;
   string version_id;

diff --git a/src/rgw/rgw_rados.cc b/src/rgw/rgw_rados.cc
index 684a6c04f974d028aa156a22a2f7e155480a79bc..644ea9cc442f6b4b59e994bd13ecda29d9b0c682 100644 (file)
--- a/src/rgw/rgw_rados.cc
+++ b/src/rgw/rgw_rados.cc
@@ -3764,7 +3764,7 @@ int RGWRados::fetch_remote_obj(RGWObjectCtx& obj_ctx,
                const char *if_nomatch,
                AttrsMod attrs_mod,
                bool copy_if_newer,
-               map<string, bufferlist>& attrs,
+               rgw::sal::RGWAttrs& attrs,
                RGWObjCategory category,
                std::optional<uint64_t> olh_epoch,
               real_time delete_at,
@@ -4147,7 +4147,7 @@ int RGWRados::copy_obj(RGWObjectCtx& obj_ctx,
                const char *if_nomatch,
                AttrsMod attrs_mod,
                bool copy_if_newer,
-               map<string, bufferlist>& attrs,
+               rgw::sal::RGWAttrs& attrs,
                RGWObjCategory category,
                uint64_t olh_epoch,
               real_time delete_at,
@@ -4434,7 +4434,7 @@ int RGWRados::copy_obj_data(RGWObjectCtx& obj_ctx,
                rgw::sal::RGWObject* dest_obj,
               real_time *mtime,
               real_time set_mtime,
-               map<string, bufferlist>& attrs,
+               rgw::sal::RGWAttrs& attrs,
                uint64_t olh_epoch,
               real_time delete_at,
                string *petag,
@@ -4516,7 +4516,7 @@ int RGWRados::transition_obj(RGWObjectCtx& obj_ctx,
                              const DoutPrefixProvider *dpp,
                              optional_yield y)
 {
-  map<string, bufferlist> attrs;
+  rgw::sal::RGWAttrs attrs;
   real_time read_mtime;
   uint64_t obj_size;
 

diff --git a/src/rgw/rgw_rados.h b/src/rgw/rgw_rados.h
index 1fb788fe8c4123a8a99bcc34aef36f4e718a566c..529c4b1011612124bf9d433268f012fca8ac328a 100644 (file)
--- a/src/rgw/rgw_rados.h
+++ b/src/rgw/rgw_rados.h
@@ -1121,7 +1121,7 @@ public:
                        const char *if_nomatch,
                        AttrsMod attrs_mod,
                        bool copy_if_newer,
-                       map<string, bufferlist>& attrs,
+                       rgw::sal::RGWAttrs& attrs,
                        RGWObjCategory category,
                        std::optional<uint64_t> olh_epoch,
                       ceph::real_time delete_at,

diff --git a/src/rgw/rgw_sal.h b/src/rgw/rgw_sal.h
index f21ca91036fa0bcb98ed89aadb4a11d6c779577d..45ed6203854c79779770e61fc07d7b2c737117df 100644 (file)
--- a/src/rgw/rgw_sal.h
+++ b/src/rgw/rgw_sal.h
@@ -338,6 +338,39 @@ class RGWObject {
       virtual int get_attr(const char *name, bufferlist& dest, optional_yield y) = 0;
     };
 
+    struct WriteOp {
+      struct Params {
+       bool versioning_disabled{false};
+       ceph::real_time* mtime{nullptr};
+       RGWAttrs* rmattrs{nullptr};
+       const bufferlist* data{nullptr};
+       RGWObjManifest* manifest{nullptr};
+       const string* ptag{nullptr};
+       list<rgw_obj_index_key>* remove_objs{nullptr};
+       ceph::real_time set_mtime;
+       ACLOwner owner;
+       RGWObjCategory category{RGWObjCategory::Main};
+       int flags{0};
+       const char* if_match{nullptr};
+       const char* if_nomatch{nullptr};
+       std::optional<uint64_t> olh_epoch;
+       ceph::real_time delete_at;
+       bool canceled{false};
+       const string* user_data{nullptr};
+       rgw_zone_set* zones_trace{nullptr};
+       bool modify_tail{false};
+       bool completeMultipart{false};
+       bool appendable{false};
+       RGWAttrs* attrs{nullptr};
+      } params;
+
+      virtual ~WriteOp() = default;
+
+      virtual int prepare(optional_yield y) = 0;
+      virtual int write_meta(uint64_t size, uint64_t accounted_size, optional_yield y) = 0;
+      //virtual int write_data(const char *data, uint64_t ofs, uint64_t len, bool exclusive) = 0;
+    };
+
     RGWObject()
       : key(),
       bucket(nullptr),
@@ -414,7 +447,8 @@ class RGWObject {
     int range_to_ofs(uint64_t obj_size, int64_t &ofs, int64_t &end);
 
     /* OPs */
-    virtual std::unique_ptr<ReadOp> get_read_op(RGWObjectCtx *) = 0;
+    virtual std::unique_ptr<ReadOp> get_read_op(RGWObjectCtx*) = 0;
+    virtual std::unique_ptr<WriteOp> get_write_op(RGWObjectCtx*) = 0;
 
     /* OMAP */
     virtual int omap_get_vals_by_keys(const std::string& oid,
@@ -434,6 +468,7 @@ class RGWObject {
       return obj;
     }
     virtual void gen_rand_obj_instance_name() = 0;
+    virtual void raw_obj_to_obj(const rgw_raw_obj& raw_obj) = 0;
 
     /* dang - This is temporary, until the API is completed */
     rgw_obj_key& get_key() { return key; }

diff --git a/src/rgw/rgw_sal_rados.cc b/src/rgw/rgw_sal_rados.cc
index 6ae2f3edd447aacddac4ed90dae695c8d867a500..e3efa4383b8386303d6987a06b23b1c9b449a834 100644 (file)
--- a/src/rgw/rgw_sal_rados.cc
+++ b/src/rgw/rgw_sal_rados.cc
@@ -33,6 +33,7 @@
 #include "rgw_rest_conn.h"
 #include "services/svc_sys_obj.h"
 #include "services/svc_zone.h"
+#include "services/svc_tier_rados.h"
 
 #define dout_subsys ceph_subsys_rgw
 
@@ -530,6 +531,13 @@ void RGWRadosObject::gen_rand_obj_instance_name()
   store->getRados()->gen_rand_obj_instance_name(&key);
 }
 
+void RGWRadosObject::raw_obj_to_obj(const rgw_raw_obj& raw_obj)
+{
+  rgw_obj tobj = get_obj();
+  RGWSI_Tier_RADOS::raw_obj_to_obj(get_bucket()->get_key(), raw_obj, &tobj);
+  set_key(tobj.key);
+}
+
 int RGWRadosObject::omap_get_vals_by_keys(const std::string& oid,
                                          const std::set<std::string>& keys,
                                          RGWAttrs *vals)
@@ -694,6 +702,56 @@ int RGWRadosObject::RadosReadOp::iterate(int64_t ofs, int64_t end, RGWGetDataCB
   return parent_op.iterate(ofs, end, cb, y);
 }
 
+std::unique_ptr<RGWObject::WriteOp> RGWRadosObject::get_write_op(RGWObjectCtx* ctx)
+{
+  return std::unique_ptr<RGWObject::WriteOp>(new RGWRadosObject::RadosWriteOp(this, ctx));
+}
+
+RGWRadosObject::RadosWriteOp::RadosWriteOp(RGWRadosObject* _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 RGWRadosObject::RadosWriteOp::prepare(optional_yield y)
+{
+  op_target.set_versioning_disabled(params.versioning_disabled);
+  parent_op.meta.mtime = params.mtime;
+  parent_op.meta.rmattrs = params.rmattrs;
+  parent_op.meta.data = params.data;
+  parent_op.meta.manifest = params.manifest;
+  parent_op.meta.ptag = params.ptag;
+  parent_op.meta.remove_objs = params.remove_objs;
+  parent_op.meta.set_mtime = params.set_mtime;
+  parent_op.meta.owner = params.owner.get_id();
+  parent_op.meta.category = params.category;
+  parent_op.meta.flags = params.flags;
+  parent_op.meta.if_match = params.if_match;
+  parent_op.meta.if_nomatch = params.if_nomatch;
+  parent_op.meta.olh_epoch = params.olh_epoch;
+  parent_op.meta.delete_at = params.delete_at;
+  parent_op.meta.canceled = params.canceled;
+  parent_op.meta.user_data = params.user_data;
+  parent_op.meta.zones_trace = params.zones_trace;
+  parent_op.meta.modify_tail = params.modify_tail;
+  parent_op.meta.completeMultipart = params.completeMultipart;
+  parent_op.meta.appendable = params.appendable;
+
+  return 0;
+}
+
+int RGWRadosObject::RadosWriteOp::write_meta(uint64_t size, uint64_t accounted_size, optional_yield y)
+{
+  int ret = parent_op.write_meta(size, accounted_size, *params.attrs, y);
+  params.canceled = parent_op.meta.canceled;
+
+  return ret;
+}
+
 int RGWRadosStore::get_bucket(RGWUser* u, const rgw_bucket& b, std::unique_ptr<RGWBucket>* bucket, optional_yield y)
 {
   int ret;

diff --git a/src/rgw/rgw_sal_rados.h b/src/rgw/rgw_sal_rados.h
index bb0acd167bdd3f12f0653bfb4e635a27c5755610..0937870de96aa6ee356cfe995545bb64c31242f4 100644 (file)
--- a/src/rgw/rgw_sal_rados.h
+++ b/src/rgw/rgw_sal_rados.h
@@ -67,6 +67,21 @@ class RGWRadosObject : public RGWObject {
       virtual int get_attr(const char *name, bufferlist& dest, optional_yield y) override;
     };
 
+    struct RadosWriteOp : public WriteOp {
+    private:
+      RGWRadosObject* source;
+      RGWObjectCtx* rctx;
+      RGWRados::Object op_target;
+      RGWRados::Object::Write parent_op;
+
+    public:
+      RadosWriteOp(RGWRadosObject* _source, RGWObjectCtx* _rctx);
+
+      virtual int prepare(optional_yield y) override;
+      virtual int write_meta(uint64_t size, uint64_t accounted_size, optional_yield y) override;
+      //virtual int write_data(const char *data, uint64_t ofs, uint64_t len, bool exclusive) override;
+    };
+
     RGWRadosObject() = default;
 
     RGWRadosObject(RGWRadosStore *_st, const rgw_obj_key& _k)
@@ -115,12 +130,14 @@ class RGWRadosObject : public RGWObject {
     virtual int copy_obj_data(RGWObjectCtx& rctx, RGWBucket* dest_bucket, RGWObject* dest_obj, uint16_t olh_epoch, std::string* petag, const DoutPrefixProvider *dpp, optional_yield y) override;
     virtual bool is_expired() override;
     virtual void gen_rand_obj_instance_name() override;
+    virtual void raw_obj_to_obj(const rgw_raw_obj& raw_obj) override;
     virtual std::unique_ptr<RGWObject> clone() {
       return std::unique_ptr<RGWObject>(new RGWRadosObject(*this));
     }
 
     /* OPs */
     virtual std::unique_ptr<ReadOp> get_read_op(RGWObjectCtx *) override;
+    virtual std::unique_ptr<WriteOp> get_write_op(RGWObjectCtx *) override;
 
     /* OMAP */
     virtual int omap_get_vals_by_keys(const std::string& oid,
@@ -211,7 +228,7 @@ class RGWRadosBucket : public RGWBucket {
                           bool *is_truncated, RGWUsageIter& usage_iter,
                           map<rgw_user_bucket, rgw_usage_log_entry>& usage) override;
     virtual std::unique_ptr<RGWBucket> clone() {
-      return std::unique_ptr<RGWBucket>(new RGWRadosBucket(*this));
+      return std::move(std::unique_ptr<RGWBucket>(new RGWRadosBucket(*this)));
     }
 
     friend class RGWRadosStore;