rgw: refactor rgw backend interface

diff --git a/src/rgw/rgw_access.h b/src/rgw/rgw_access.h
index c7a1798fbf5656600d5ad7bd6d30087951f4eb1d..c22ed2d5a11ec882f488fd51f698fb28ff739fd6 100644 (file)
--- a/src/rgw/rgw_access.h
+++ b/src/rgw/rgw_access.h
@@ -46,16 +46,16 @@ public:
   virtual int create_bucket(std::string& id, std::string& bucket, map<std::string, bufferlist>& attrs, uint64_t auid=0) = 0;
   /** write an object to the storage device in the appropriate pool
     with the given stats */
-  virtual int put_obj_meta(std::string& id, std::string& bucket, std::string& obj, std::string& loc, time_t *mtime,
+  virtual int put_obj_meta(std::string& id, rgw_obj& obj, std::string& loc, time_t *mtime,
                       map<std::string, bufferlist>& attrs, bool exclusive) = 0;
-  virtual int put_obj_data(std::string& id, std::string& bucket, std::string& obj, std::string& loc, const char *data,
+  virtual int put_obj_data(std::string& id, rgw_obj& obj, std::string& loc, const char *data,
                       off_t ofs, size_t len, time_t *mtime) = 0;
 
-  int put_obj(std::string& id, std::string& bucket, std::string& obj, std::string& loc, const char *data, size_t len,
+  int put_obj(std::string& id, rgw_obj& obj, std::string& loc, const char *data, size_t len,
               time_t *mtime, map<std::string, bufferlist>& attrs) {
-    int ret = put_obj_meta(id, bucket, obj, loc, NULL, attrs, false);
+    int ret = put_obj_meta(id, obj, loc, NULL, attrs, false);
     if (ret >= 0) {
-      ret = put_obj_data(id, bucket, obj, loc, data, -1, len, mtime);
+      ret = put_obj_data(id, obj, loc, data, -1, len, mtime);
     }
     return ret;
   }
@@ -73,8 +73,8 @@ public:
    * err: stores any errors resulting from the get of the original object
    * Returns: 0 on success, -ERR# otherwise.
    */
-  virtual int copy_obj(std::string& id, std::string& dest_bucket, std::string& dest_obj,
-                      std::string& src_bucket, std::string& src_obj,
+  virtual int copy_obj(std::string& id, rgw_obj& dest_obj,
+                      rgw_obj& src_obj,
                       time_t *mtime,
                       const time_t *mod_ptr,
                       const time_t *unmod_ptr,
@@ -97,7 +97,7 @@ public:
    * obj: name of the object to delete
    * Returns: 0 on success, -ERR# otherwise.
    */
-  virtual int delete_obj(std::string& id, std::string& bucket, std::string& obj) = 0;
+  virtual int delete_obj(std::string& id, rgw_obj& obj) = 0;
 
 /**
  * Get data about an object out of RADOS and into memory.
@@ -121,7 +121,7 @@ public:
  *          (if get_data==true) length of read data,
  *          (if get_data==false) length of the object
  */
-  virtual int prepare_get_obj(std::string& bucket, std::string& obj, std::string& loc,
+  virtual int prepare_get_obj(rgw_obj& obj, std::string& loc,
             off_t ofs, off_t *end,
             map<string, bufferlist> *attrs,
             const time_t *mod_ptr,
@@ -133,17 +133,18 @@ public:
             void **handle,
             struct rgw_err *err) = 0;
 
-  virtual int get_obj(void **handle, std::string& bucket, std::string& oid, std::string& loc,
+  virtual int get_obj(void **handle, rgw_obj& obj, std::string& loc,
             char **data, off_t ofs, off_t end) = 0;
 
   virtual void finish_get_obj(void **handle) = 0;
 
-  virtual int clone_range(std::string& bucket, std::string& dst_oid, off_t dst_ofs,
-                          std::string& src_oid, off_t src_ofs, size_t size, std::string& loc) = 0;
+  virtual int clone_range(rgw_obj& dst_obj, off_t dst_ofs,
+                          rgw_obj& src_obj, off_t src_ofs,
+                          size_t size, std::string& loc) = 0;
  /**
    * a simple object read without keeping state
    */
-  virtual int read(std::string& bucket, std::string& oid, off_t ofs, size_t size, bufferlist& bl) = 0;
+  virtual int read(rgw_obj& obj, off_t ofs, size_t size, bufferlist& bl) = 0;
 
   /**
    * Get the attributes for an object.
@@ -153,8 +154,8 @@ public:
    * dest: bufferlist to store the result in
    * Returns: 0 on success, -ERR# otherwise.
    */
-  virtual int get_attr(std::string& bucket, std::string& obj, std::string& loc,
-                       const char *name, bufferlist& dest) = 0;
+  virtual int get_attr(rgw_obj& obj, std::string& loc, const char *name, bufferlist& dest) = 0;
+
   /**
    * Set an attr on an object.
    * bucket: name of the bucket holding the object
@@ -163,23 +164,22 @@ public:
    * bl: the contents of the attr
    * Returns: 0 on success, -ERR# otherwise.
    */
-  virtual int set_attr(std::string& bucket, std::string& obj,
-                       const char *name, bufferlist& bl) = 0;
+  virtual int set_attr(rgw_obj& obj, const char *name, bufferlist& bl) = 0;
 
  /**
   * stat an object
   */
-  virtual int obj_stat(std::string& bucket, std::string& obj, uint64_t *psize, time_t *pmtime) = 0;
+  virtual int obj_stat(rgw_obj& obj, uint64_t *psize, time_t *pmtime) = 0;
 
   virtual bool supports_tmap() { return false; }
 
-  virtual int tmap_set(std::string& bucket, std::string& obj, std::string& key, bufferlist& bl) { return -ENOTSUP; }
-  virtual int tmap_create(std::string& bucket, std::string& obj, std::string& key, bufferlist& bl) { return -ENOTSUP; }
-  virtual int tmap_del(std::string& bucket, std::string& obj, std::string& key) { return -ENOTSUP; }
+  virtual int tmap_set(rgw_obj& obj, std::string& key, bufferlist& bl) { return -ENOTSUP; }
+  virtual int tmap_create(rgw_obj& obj, std::string& key, bufferlist& bl) { return -ENOTSUP; }
+  virtual int tmap_del(rgw_obj& obj, std::string& key) { return -ENOTSUP; }
 
   virtual int update_containers_stats(map<string, RGWBucketEnt>& m) { return -ENOTSUP; }
 
-  virtual int append_async(std::string& bucket, std::string& oid, size_t size, bufferlist& bl) { return -ENOTSUP; }
+  virtual int append_async(rgw_obj& obj, size_t size, bufferlist& bl) { return -ENOTSUP; }
 
 
  /** 

diff --git a/src/rgw/rgw_admin.cc b/src/rgw/rgw_admin.cc
index ed54e0d9eba14198b086d3db4a4ffa22d1839355..4e371e284fd8fd8d9a54a8b9fbd280278ee3022c 100644 (file)
--- a/src/rgw/rgw_admin.cc
+++ b/src/rgw/rgw_admin.cc
@@ -549,8 +549,8 @@ int main(int argc, char **argv)
       object = "";
     string bucket_str(bucket);
     string object_str(object);
-    int ret = store->get_attr(bucket_str, object_str, object_str,
-                       RGW_ATTR_ACL, bl);
+    rgw_obj obj(bucket_str, object_str);
+    int ret = store->get_attr(obj, object_str, RGW_ATTR_ACL, bl);
 
     RGWAccessControlPolicy policy;
     if (ret >= 0) {
@@ -620,14 +620,15 @@ int main(int argc, char **argv)
     }
 
     uint64_t size;
-    int r = store->obj_stat(log_bucket, oid, &size, NULL);
+    rgw_obj obj(log_bucket, oid);
+    int r = store->obj_stat(obj, &size, NULL);
     if (r < 0) {
       cerr << "error while doing stat on " <<  log_bucket << ":" << oid
           << " " << cpp_strerror(-r) << std::endl;
       return -r;
     }
     bufferlist bl;
-    r = store->read(log_bucket, oid, 0, size, bl);
+    r = store->read(obj, 0, size, bl);
     if (r < 0) {
       cerr << "error while reading from " <<  log_bucket << ":" << oid
           << " " << cpp_strerror(-r) << std::endl;

diff --git a/src/rgw/rgw_common.h b/src/rgw/rgw_common.h
index ecd64a207951398e10f01c3d4111f536cf182041..30d53ce97547d0b086c14fa1554c3cb1aa2e2d24 100644 (file)
--- a/src/rgw/rgw_common.h
+++ b/src/rgw/rgw_common.h
@@ -448,6 +448,19 @@ struct RGWUploadPartInfo {
 };
 WRITE_CLASS_ENCODER(RGWUploadPartInfo)
 
+class rgw_obj {
+public:
+  std::string bucket;
+  std::string object;
+
+  rgw_obj() {}
+  rgw_obj(std::string& b, std::string& o) : bucket(b), object(o) {}
+  void init(std::string& b, std::string& o) {
+    bucket = b;
+    object = o;
+  }
+};
+
 static inline void buf_to_hex(const unsigned char *buf, int len, char *str)
 {
   int i;

diff --git a/src/rgw/rgw_fs.cc b/src/rgw/rgw_fs.cc
index 9dbb3949b247350cbc5103b49e16347abc88c0cc..312105ce5b3c9a6fce1cd566f1986605d68d7eb1 100644 (file)
--- a/src/rgw/rgw_fs.cc
+++ b/src/rgw/rgw_fs.cc
@@ -89,7 +89,7 @@ int RGWFS::list_buckets_next(string& id, RGWObjEnt& obj, RGWAccessHandle *handle
   }
 }
 
-int RGWFS::obj_stat(string& bucket, string& obj, uint64_t *psize, time_t *pmtime)
+int RGWFS::obj_stat(rgw_obj& obj, uint64_t *psize, time_t *pmtime)
 {
   return -ENOTSUP;
 }
@@ -185,12 +185,14 @@ int RGWFS::create_bucket(std::string& id, std::string& bucket, map<std::string,
   return 0;
 }
 
-int RGWFS::put_obj_meta(std::string& id, std::string& bucket, std::string& obj, std::string& loc,
+int RGWFS::put_obj_meta(std::string& id, rgw_obj& obj, std::string& loc,
                   time_t *mtime, map<string, bufferlist>& attrs, bool exclusive)
 {
-  int len = strlen(DIR_NAME) + 1 + bucket.size() + 1 + obj.size() + 1;
+  std::string& bucket = obj.bucket;
+  std::string& oid = obj.object;
+  int len = strlen(DIR_NAME) + 1 + bucket.size() + 1 + oid.size() + 1;
   char buf[len];
-  snprintf(buf, len, "%s/%s/%s", DIR_NAME, bucket.c_str(), obj.c_str());
+  snprintf(buf, len, "%s/%s/%s", DIR_NAME, bucket.c_str(), oid.c_str());
   int fd;
 
   fd = open(buf, O_CREAT | O_WRONLY | (exclusive ? O_EXCL : 0), 0755);
@@ -230,12 +232,14 @@ done_err:
   return -errno;
 }
 
-int RGWFS::put_obj_data(std::string& id, std::string& bucket, std::string& obj, std::string& loc, const char *data,
+int RGWFS::put_obj_data(std::string& id, rgw_obj& obj, std::string& loc, const char *data,
                   off_t ofs, size_t size, time_t *mtime)
 {
-  int len = strlen(DIR_NAME) + 1 + bucket.size() + 1 + obj.size() + 1;
+  std::string& bucket = obj.bucket;
+  std::string& oid = obj.object;
+  int len = strlen(DIR_NAME) + 1 + bucket.size() + 1 + oid.size() + 1;
   char buf[len];
-  snprintf(buf, len, "%s/%s/%s", DIR_NAME, bucket.c_str(), obj.c_str());
+  snprintf(buf, len, "%s/%s/%s", DIR_NAME, bucket.c_str(), oid.c_str());
   int fd;
 
   int open_flags = O_CREAT | O_WRONLY;
@@ -277,8 +281,8 @@ done_err:
   return r;
 }
 
-int RGWFS::copy_obj(std::string& id, std::string& dest_bucket, std::string& dest_obj,
-               std::string& src_bucket, std::string& src_obj,
+int RGWFS::copy_obj(std::string& id, rgw_obj& dest_obj,
+               rgw_obj& src_obj,
                time_t *mtime,
                const time_t *mod_ptr,
                const time_t *unmod_ptr,
@@ -287,6 +291,10 @@ int RGWFS::copy_obj(std::string& id, std::string& dest_bucket, std::string& dest
                map<string, bufferlist>& attrs,
                struct rgw_err *err)
 {
+  std::string& dest_bucket = dest_obj.bucket;
+  std::string& dest_oid = dest_obj.object;
+  std::string& src_bucket = src_obj.bucket;
+  std::string& src_oid = src_obj.object;
   int ret;
   char *data;
   void *handle;
@@ -295,13 +303,13 @@ int RGWFS::copy_obj(std::string& id, std::string& dest_bucket, std::string& dest
   time_t lastmod;
 
   map<string, bufferlist> attrset;
-  ret = prepare_get_obj(src_bucket, src_obj, src_obj, 0, &end, &attrset, mod_ptr, unmod_ptr, &lastmod,
+  ret = prepare_get_obj(src_obj, src_oid, 0, &end, &attrset, mod_ptr, unmod_ptr, &lastmod,
                         if_match, if_nomatch, &total_len, &handle, err);
   if (ret < 0)
     return ret;
  
   do { 
-    ret = get_obj(&handle, src_bucket, src_obj, src_obj, &data, ofs, end);
+    ret = get_obj(&handle, src_obj, src_oid, &data, ofs, end);
     if (ret < 0)
       return ret;
     ofs += ret;
@@ -313,7 +321,7 @@ int RGWFS::copy_obj(std::string& id, std::string& dest_bucket, std::string& dest
   }
   attrs = attrset;
 
-  ret = put_obj(id, dest_bucket, dest_obj, dest_obj, data, ret, mtime, attrs);
+  ret = put_obj(id, dest_obj, dest_oid, data, ret, mtime, attrs);
 
   return ret;
 }
@@ -331,11 +339,13 @@ int RGWFS::delete_bucket(std::string& id, std::string& bucket)
 }
 
 
-int RGWFS::delete_obj(std::string& id, std::string& bucket, std::string& obj)
+int RGWFS::delete_obj(std::string& id, rgw_obj& obj)
 {
-  int len = strlen(DIR_NAME) + 1 + bucket.size() + 1 + obj.size() + 1;
+  std::string& bucket = obj.bucket;
+  std::string& oid = obj.object;
+  int len = strlen(DIR_NAME) + 1 + bucket.size() + 1 + oid.size() + 1;
   char buf[len];
-  snprintf(buf, len, "%s/%s/%s", DIR_NAME, bucket.c_str(), obj.c_str());
+  snprintf(buf, len, "%s/%s/%s", DIR_NAME, bucket.c_str(), oid.c_str());
 
   if (unlink(buf) < 0)
     return -errno;
@@ -397,15 +407,17 @@ int RGWFS::get_attr(const char *name, const char *path, char **attr)
   return attr_len;
 }
 
-int RGWFS::get_attr(std::string& bucket, std::string& obj, std::string& loc,
+int RGWFS::get_attr(rgw_obj& obj, std::string& loc,
                        const char *name, bufferlist& dest)
 {
-  int len = strlen(DIR_NAME) + 1 + bucket.size() + 1 + obj.size() + 1;
+  std::string& bucket = obj.bucket;
+  std::string& oid = obj.object;
+  int len = strlen(DIR_NAME) + 1 + bucket.size() + 1 + oid.size() + 1;
   char buf[len];
   int r = -EINVAL;
   char *data = NULL;
 
-  snprintf(buf, len, "%s/%s/%s", DIR_NAME, bucket.c_str(), obj.c_str());
+  snprintf(buf, len, "%s/%s/%s", DIR_NAME, bucket.c_str(), oid.c_str());
 
   r = get_attr(name, buf, &data);
   if (r < 0)
@@ -417,14 +429,16 @@ done:
   return r;
 }
 
-int RGWFS::set_attr(std::string& bucket, std::string& obj,
+int RGWFS::set_attr(rgw_obj& obj,
                        const char *name, bufferlist& bl)
 {
-  int len = strlen(DIR_NAME) + 1 + bucket.size() + 1 + obj.size() + 1;
+  std::string& bucket = obj.bucket;
+  std::string& oid = obj.object;
+  int len = strlen(DIR_NAME) + 1 + bucket.size() + 1 + oid.size() + 1;
   char buf[len];
   int r;
 
-  snprintf(buf, len, "%s/%s/%s", DIR_NAME, bucket.c_str(), obj.c_str());
+  snprintf(buf, len, "%s/%s/%s", DIR_NAME, bucket.c_str(), oid.c_str());
 
   r = setxattr(buf, name, bl.c_str(), bl.length(), 0);
 
@@ -434,7 +448,7 @@ int RGWFS::set_attr(std::string& bucket, std::string& obj,
   return ret;
 }
 
-int RGWFS::prepare_get_obj(std::string& bucket, std::string& obj, std::string& loc,
+int RGWFS::prepare_get_obj(rgw_obj& obj, std::string& loc,
             off_t ofs, off_t *end,
             map<string, bufferlist> *attrs,
             const time_t *mod_ptr,
@@ -446,7 +460,9 @@ int RGWFS::prepare_get_obj(std::string& bucket, std::string& obj, std::string& l
             void **handle,
             struct rgw_err *err)
 {
-  int len = strlen(DIR_NAME) + 1 + bucket.size() + 1 + obj.size() + 1;
+  std::string& bucket = obj.bucket;
+  std::string& oid = obj.object;
+  int len = strlen(DIR_NAME) + 1 + bucket.size() + 1 + oid.size() + 1;
   char buf[len];
   int fd;
   struct stat st;
@@ -460,7 +476,7 @@ int RGWFS::prepare_get_obj(std::string& bucket, std::string& obj, std::string& l
   if (!state)
     return -ENOMEM;
 
-  snprintf(buf, len, "%s/%s/%s", DIR_NAME, bucket.c_str(), obj.c_str());
+  snprintf(buf, len, "%s/%s/%s", DIR_NAME, bucket.c_str(), oid.c_str());
 
   fd = open(buf, O_RDONLY, 0755);
 
@@ -536,7 +552,7 @@ done_err:
   return r;
 }
 
-int RGWFS::get_obj(void **handle, std::string& bucket, std::string& obj, std::string& loc,
+int RGWFS::get_obj(void **handle, rgw_obj& obj, std::string& loc,
             char **data, off_t ofs, off_t end)
 {
   uint64_t len;
@@ -592,8 +608,10 @@ void RGWFS::finish_get_obj(void **handle)
   }
 }
 
-int RGWFS::read(std::string& bucket, std::string& oid, off_t ofs, size_t size, bufferlist& bl)
+int RGWFS::read(rgw_obj& obj, off_t ofs, size_t size, bufferlist& bl)
 {
+  std::string& bucket = obj.bucket;
+  std::string& oid = obj.object;
   int len = strlen(DIR_NAME) + 1 + bucket.size() + 1 + oid.size() + 1;
   char buf[len];
   int fd;

diff --git a/src/rgw/rgw_fs.h b/src/rgw/rgw_fs.h
index 8058c3309c6bf52de13cde8b8518d7541dfdeebf..cd5cfc8ae25f9c42cb68eef3b966d53cc8c550c8 100644 (file)
--- a/src/rgw/rgw_fs.h
+++ b/src/rgw/rgw_fs.h
@@ -19,14 +19,14 @@ public:
                    bool get_content_type);
 
   int create_bucket(std::string& id, std::string& bucket, map<std::string, bufferlist>& attrs, uint64_t auid=0);
-  int put_obj_meta(std::string& id, std::string& bucket, std::string& obj, std::string& loc, time_t *mtime,
+  int put_obj_meta(std::string& id, rgw_obj& obj, std::string& loc, time_t *mtime,
              map<std::string, bufferlist>& attrs, bool exclusive);
-  int put_obj_data(std::string& id, std::string& bucket, std::string& obj, std::string& loc, const char *data,
+  int put_obj_data(std::string& id, rgw_obj& obj, std::string& loc, const char *data,
               off_t ofs, size_t size, time_t *mtime);
-  int clone_range(std::string& bucket, std::string& dst_oid, off_t dst_ofs,
-                  std::string& src_oid, off_t src_ofs, size_t size, std::string& loc) { return -ENOTSUP; }
-  int copy_obj(std::string& id, std::string& dest_bucket, std::string& dest_obj,
-               std::string& src_bucket, std::string& src_obj,
+  int clone_range(rgw_obj& dst_obj, off_t dst_ofs,
+                  rgw_obj& src_obj, off_t src_ofs, size_t size, std::string& loc) { return -ENOTSUP; }
+  int copy_obj(std::string& id, rgw_obj& dest_obj,
+               rgw_obj& src_obj,
                time_t *mtime,
                const time_t *mod_ptr,
                const time_t *unmod_ptr,
@@ -35,16 +35,14 @@ public:
                map<std::string, bufferlist>& attrs,
                struct rgw_err *err);
   int delete_bucket(std::string& id, std::string& bucket);
-  int delete_obj(std::string& id, std::string& bucket, std::string& obj);
+  int delete_obj(std::string& id, rgw_obj& obj);
 
   int get_attr(const char *name, int fd, char **attr);
   int get_attr(const char *name, const char *path, char **attr);
-  int get_attr(std::string& bucket, std::string& obj, std::string& loc,
-               const char *name, bufferlist& dest);
-  int set_attr(std::string& bucket, std::string& obj,
-                       const char *name, bufferlist& bl);
+  int get_attr(rgw_obj& obj, std::string& loc, const char *name, bufferlist& dest);
+  int set_attr(rgw_obj& obj, const char *name, bufferlist& bl);
 
-  int prepare_get_obj(std::string& bucket, std::string& obj, std::string& loc,
+  int prepare_get_obj(rgw_obj& obj, std::string& loc,
             off_t ofs, off_t *end,
            map<std::string, bufferlist> *attrs,
             const time_t *mod_ptr,
@@ -56,12 +54,12 @@ public:
             void **handle,
             struct rgw_err *err);
 
-  int get_obj(void **handle, std::string& bucket, std::string& obj, std::string& loc,
+  int get_obj(void **handle, rgw_obj& obj, std::string& loc,
             char **data, off_t ofs, off_t end);
 
   void finish_get_obj(void **handle);
-  int read(std::string& bucket, std::string& oid, off_t ofs, size_t size, bufferlist& bl);
-  int obj_stat(string& bucket, string& obj, uint64_t *psize, time_t *pmtime);
+  int read(rgw_obj& obj, off_t ofs, size_t size, bufferlist& bl);
+  int obj_stat(rgw_obj& obj, uint64_t *psize, time_t *pmtime);
 };
 
 #endif

diff --git a/src/rgw/rgw_log.cc b/src/rgw/rgw_log.cc
index 5f8723061c370e2fae426709a18661c76cb70b1b..ce9b0bf4a1b72cc2a9c46064374a0fe9c9611240 100644 (file)
--- a/src/rgw/rgw_log.cc
+++ b/src/rgw/rgw_log.cc
@@ -69,9 +69,11 @@ int rgw_log_op(struct req_state *s)
   
   char buf[entry.bucket.size() + 16];
   sprintf(buf, "%.4d-%.2d-%.2d-%s", (bdt.tm_year+1900), (bdt.tm_mon+1), bdt.tm_mday, entry.bucket.c_str());
-  string oid = buf;
+  rgw_obj obj;
+  obj.bucket = log_bucket;
+  obj.object = buf;
 
-  int ret = rgwstore->append_async(log_bucket, oid, bl.length(), bl);
+  int ret = rgwstore->append_async(obj, bl.length(), bl);
 
   if (ret == -ENOENT) {
     string id;
@@ -79,7 +81,8 @@ int rgw_log_op(struct req_state *s)
     ret = rgwstore->create_bucket(id, log_bucket, attrs);
     if (ret < 0)
       goto done;
-    ret = rgwstore->append_async(log_bucket, entry.bucket, bl.length(), bl);
+    obj.object = entry.bucket;
+    ret = rgwstore->append_async(obj, bl.length(), bl);
   }
 done:
   if (ret < 0)

diff --git a/src/rgw/rgw_op.cc b/src/rgw/rgw_op.cc
index b860ba8e10f959411a382931bfce0f88881dd3a7..1d758e3cfe170cc9f5f9f497d5a9cb10c23f08c4 100644 (file)
--- a/src/rgw/rgw_op.cc
+++ b/src/rgw/rgw_op.cc
@@ -90,8 +90,8 @@ static int get_policy_from_attr(RGWAccessControlPolicy *policy, string& bucket,
   int ret = 0;
 
   if (bucket.size()) {
-    ret = rgwstore->get_attr(bucket, object, loc,
-                       RGW_ATTR_ACL, bl);
+    rgw_obj obj(bucket, object);
+    ret = rgwstore->get_attr(obj, loc, RGW_ATTR_ACL, bl);
 
     if (ret >= 0) {
       bufferlist::iterator iter = bl.begin();
@@ -169,6 +169,7 @@ int read_acls(struct req_state *s, bool only_bucket)
 void RGWGetObj::execute()
 {
   void *handle = NULL;
+  rgw_obj obj;
 
   if (!verify_permission(s, RGW_PERM_READ)) {
     ret = -EACCES;
@@ -181,7 +182,8 @@ void RGWGetObj::execute()
 
   init_common();
 
-  ret = rgwstore->prepare_get_obj(s->bucket_str, s->object_str, s->object_str, ofs, &end, &attrs, mod_ptr,
+  obj.init(s->bucket_str, s->object_str);
+  ret = rgwstore->prepare_get_obj(obj, s->object_str, ofs, &end, &attrs, mod_ptr,
                                   unmod_ptr, &lastmod, if_match, if_nomatch, &total_len, &handle, &s->err);
   if (ret < 0)
     goto done;
@@ -192,7 +194,7 @@ void RGWGetObj::execute()
     goto done;
 
   while (ofs <= end) {
-    ret = rgwstore->get_obj(&handle, s->bucket_str, s->object_str, s->object_str, &data, ofs, end);
+    ret = rgwstore->get_obj(&handle, obj, s->object_str, &data, ofs, end);
     if (ret < 0) {
       goto done;
     }
@@ -424,31 +426,32 @@ void RGWPutObj::execute()
     }
 
     MD5 hash;
-    string obj;
+    string oid;
     multipart = s->args.exists("uploadId");
     if (!multipart) {
-      obj = s->object_str;
+      oid = s->object_str;
     } else {
-      obj = s->object_str;
-      obj.append(".");
-      obj.append(s->args.get("uploadId"));
-      multipart_meta_obj = obj;
+      oid = s->object_str;
+      oid.append(".");
+      oid.append(s->args.get("uploadId"));
+      multipart_meta_obj = oid;
       part_num = s->args.get("partNumber");
       if (part_num.empty()) {
         ret = -EINVAL;
         goto done;
       }
-      obj.append(".");
-      obj.append(part_num);
+      oid.append(".");
+      oid.append(part_num);
     }
+    rgw_obj obj(s->bucket_str, oid);
     do {
       get_data();
       if (len > 0) {
         hash.Update((unsigned char *)data, len);
        // For the first call to put_obj_data, pass -1 as the offset to
        // do a write_full.
-        ret = rgwstore->put_obj_data(s->user.user_id, s->bucket_str,
-                                    obj, s->object_str, data,
+        ret = rgwstore->put_obj_data(s->user.user_id, obj,
+                                    s->object_str, data,
                                     ((ofs == 0) ? -1 : ofs), len, NULL);
         free(data);
         if (ret < 0)
@@ -485,7 +488,7 @@ void RGWPutObj::execute()
 
     get_request_metadata(s, attrs);
 
-    ret = rgwstore->put_obj_meta(s->user.user_id, s->bucket_str, obj, s->object_str, NULL, attrs, false);
+    ret = rgwstore->put_obj_meta(s->user.user_id, obj, s->object_str, NULL, attrs, false);
     if (ret < 0)
       goto done;
 
@@ -502,8 +505,10 @@ void RGWPutObj::execute()
       ::encode(info, bl);
       RGW_LOG(0) << "JJJ name=" << p << "bl.length()=" << bl.length() << dendl;
       meta_attrs[p] = bl;
+
+      rgw_obj meta_obj(s->bucket_str, multipart_meta_obj);
       
-      ret  = rgwstore->put_obj_meta(s->user.user_id, s->bucket_str, multipart_meta_obj, s->object_str, NULL, meta_attrs, false);
+      ret  = rgwstore->put_obj_meta(s->user.user_id, meta_obj, s->object_str, NULL, meta_attrs, false);
     }
   }
 done:
@@ -513,8 +518,9 @@ done:
 void RGWDeleteObj::execute()
 {
   ret = -EINVAL;
+  rgw_obj obj(s->bucket_str, s->object_str);
   if (s->object) {
-    ret = rgwstore->delete_obj(s->user.user_id, s->bucket_str, s->object_str);
+    ret = rgwstore->delete_obj(s->user.user_id, obj);
   }
 
   send_response();
@@ -611,6 +617,8 @@ int RGWCopyObj::init_common()
 
 void RGWCopyObj::execute()
 {
+  rgw_obj src_obj, dst_obj;
+
   ret = get_params();
   if (ret < 0)
     goto done;
@@ -618,9 +626,11 @@ void RGWCopyObj::execute()
   if (init_common() < 0)
     goto done;
 
+  src_obj.init(src_bucket, src_object);
+  dst_obj.init(s->bucket_str, s->object_str);
   ret = rgwstore->copy_obj(s->user.user_id,
-                        s->bucket_str, s->object_str,
-                        src_bucket, src_object,
+                        dst_obj,
+                        src_obj,
                         &mtime,
                         mod_ptr,
                         unmod_ptr,
@@ -738,6 +748,7 @@ void RGWPutACLs::execute()
   char *orig_data = data;
   char *new_data = NULL;
   ACLOwner owner;
+  rgw_obj obj;
 
   if (!verify_permission(s, RGW_PERM_WRITE_ACP)) {
     ret = -EACCES;
@@ -813,8 +824,8 @@ void RGWPutACLs::execute()
   }
 
   new_policy.encode(bl);
-  ret = rgwstore->set_attr(s->bucket_str, s->object_str,
-                       RGW_ATTR_ACL, bl);
+  obj.init(s->bucket_str, s->object_str);
+  ret = rgwstore->set_attr(obj, RGW_ATTR_ACL, bl);
 
 done:
   free(orig_data);
@@ -829,6 +840,7 @@ void RGWInitMultipart::execute()
   bufferlist aclbl;
   RGWAccessControlPolicy policy;
   map<string, bufferlist> attrs;
+  rgw_obj obj;
 
   if (get_params() < 0)
     goto done;
@@ -867,20 +879,23 @@ void RGWInitMultipart::execute()
     tmp_obj_name.append(".");
     tmp_obj_name.append(upload_id);
 
-    ret = rgwstore->put_obj_meta(s->user.user_id, s->bucket_str, tmp_obj_name, s->object_str, NULL, attrs, true);
+    obj.init(s->bucket_str, tmp_obj_name);
+    ret = rgwstore->put_obj_meta(s->user.user_id, obj, s->object_str, NULL, attrs, true);
   } while (ret == -EEXIST);
 done:
   send_response();
 }
 
-static int get_multiparts_info(struct req_state *s, string& obj, map<uint32_t, RGWUploadPartInfo>& parts,
+static int get_multiparts_info(struct req_state *s, string& oid, map<uint32_t, RGWUploadPartInfo>& parts,
                                RGWAccessControlPolicy& policy, map<string, bufferlist>& new_attrs)
 {
   void *handle;
   map<string, bufferlist> attrs;
   map<string, bufferlist>::iterator iter;
 
-  int ret = rgwstore->prepare_get_obj(s->bucket_str, obj, s->object_str, 0, NULL, &attrs, NULL,
+  rgw_obj obj(s->bucket_str, oid);
+
+  int ret = rgwstore->prepare_get_obj(obj, s->object_str, 0, NULL, &attrs, NULL,
                                       NULL, NULL, NULL, NULL, NULL, &handle, &s->err);
   rgwstore->finish_get_obj(&handle);
 
@@ -915,8 +930,8 @@ void RGWCompleteMultipart::execute()
   RGWMultiCompleteUpload *parts;
   map<int, string>::iterator iter;
   RGWMultiXMLParser parser;
-  string obj = s->object_str;
-  string meta_obj;
+  string oid = s->object_str;
+  string meta_oid;
   map<uint32_t, RGWUploadPartInfo> obj_parts;
   map<uint32_t, RGWUploadPartInfo>::iterator obj_iter;
   RGWAccessControlPolicy policy;
@@ -927,7 +942,8 @@ void RGWCompleteMultipart::execute()
   char final_etag[CEPH_CRYPTO_MD5_DIGESTSIZE];
   char final_etag_str[CEPH_CRYPTO_MD5_DIGESTSIZE * 2 + 16];
   bufferlist etag_bl;
-
+  rgw_obj meta_obj;
+  rgw_obj target_obj;
 
 
   ret = get_params();
@@ -955,13 +971,13 @@ void RGWCompleteMultipart::execute()
     goto done;
   }
 
-  obj.append(".");
-  obj.append(upload_id);
-  meta_obj = obj;
-  prefix = obj;
+  oid.append(".");
+  oid.append(upload_id);
+  meta_oid = oid;
+  prefix = oid;
   prefix.append(".");
 
-  ret = get_multiparts_info(s, obj, obj_parts, policy, attrs);
+  ret = get_multiparts_info(s, oid, obj_parts, policy, attrs);
   if (ret == -ENOENT)
     ret = -ERR_NO_SUCH_UPLOAD;
   if (parts->parts.size() != obj_parts.size())
@@ -998,29 +1014,34 @@ void RGWCompleteMultipart::execute()
 
   attrs[RGW_ATTR_ETAG] = etag_bl;
 
-  ret = rgwstore->put_obj_meta(s->user.user_id, s->bucket_str, s->object_str, s->object_str, NULL, attrs, false);
+  target_obj.init(s->bucket_str, s->object_str);
+  ret = rgwstore->put_obj_meta(s->user.user_id, target_obj, s->object_str, NULL, attrs, false);
   if (ret < 0)
     goto done;
 
   for (obj_iter = obj_parts.begin(); obj_iter != obj_parts.end(); ++obj_iter) {
-    obj = prefix;
+    oid = prefix;
     char buf[16];
     snprintf(buf, sizeof(buf), "%d", obj_iter->second.num);
-    obj.append(buf);
-    rgwstore->clone_range(s->bucket_str, s->object_str, ofs, obj, 0, obj_iter->second.size, s->object_str);
+    oid.append(buf);
+    rgw_obj src_obj(s->bucket_str, oid);
+    rgw_obj dst_obj(s->bucket_str, s->object_str);
+    rgwstore->clone_range(dst_obj, ofs, src_obj, 0, obj_iter->second.size, s->object_str);
     ofs += obj_iter->second.size;
   }
 
   // now erase all parts
   for (obj_iter = obj_parts.begin(); obj_iter != obj_parts.end(); ++obj_iter) {
-    obj = prefix;
+    oid = prefix;
     char buf[16];
     snprintf(buf, sizeof(buf), "%d", obj_iter->second.num);
-    obj.append(buf);
-    rgwstore->delete_obj(s->user.user_id, s->bucket_str, obj);
+    oid.append(buf);
+    rgw_obj obj(s->bucket_str, oid);
+    rgwstore->delete_obj(s->user.user_id, obj);
   }
   // and also remove the metadata obj
-  rgwstore->delete_obj(s->user.user_id, s->bucket_str, meta_obj);
+  meta_obj.init(s->bucket_str, meta_oid);
+  rgwstore->delete_obj(s->user.user_id, meta_obj);
 
 
 done:

diff --git a/src/rgw/rgw_rados.cc b/src/rgw/rgw_rados.cc
index 8b1697406cb5ba1a613a8ea3b5d743a32fdb2a61..41b7379efcc7ec9f949af7698b53a50dbb01ea9a 100644 (file)
--- a/src/rgw/rgw_rados.cc
+++ b/src/rgw/rgw_rados.cc
@@ -256,9 +256,11 @@ int RGWRados::create_bucket(std::string& id, std::string& bucket, map<std::strin
  * exclusive: create object exclusively
  * Returns: 0 on success, -ERR# otherwise.
  */
-int RGWRados::put_obj_meta(std::string& id, std::string& bucket, std::string& oid, std::string& loc,
+int RGWRados::put_obj_meta(std::string& id, rgw_obj& obj, std::string& loc,
                   time_t *mtime, map<string, bufferlist>& attrs, bool exclusive)
 {
+  std::string& bucket = obj.bucket;
+  std::string& oid = obj.object;
   librados::IoCtx io_ctx;
 
   int r = open_bucket_ctx(bucket, io_ctx);
@@ -307,9 +309,11 @@ int RGWRados::put_obj_meta(std::string& id, std::string& bucket, std::string& oi
  * attrs: all the given attrs are written to bucket storage for the given object
  * Returns: 0 on success, -ERR# otherwise.
  */
-int RGWRados::put_obj_data(std::string& id, std::string& bucket, std::string& oid, std::string& loc,
+int RGWRados::put_obj_data(std::string& id, rgw_obj& obj, std::string& loc,
                           const char *data, off_t ofs, size_t len, time_t *mtime)
 {
+  std::string& bucket = obj.bucket;
+  std::string& oid = obj.object;
   librados::IoCtx io_ctx;
 
   int r = open_bucket_ctx(bucket, io_ctx);
@@ -353,8 +357,8 @@ int RGWRados::put_obj_data(std::string& id, std::string& bucket, std::string& oi
  * err: stores any errors resulting from the get of the original object
  * Returns: 0 on success, -ERR# otherwise.
  */
-int RGWRados::copy_obj(std::string& id, std::string& dest_bucket, std::string& dest_obj,
-               std::string& src_bucket, std::string& src_obj,
+int RGWRados::copy_obj(std::string& id, rgw_obj& dest_obj,
+               rgw_obj& src_obj,
                time_t *mtime,
                const time_t *mod_ptr,
                const time_t *unmod_ptr,
@@ -363,6 +367,10 @@ int RGWRados::copy_obj(std::string& id, std::string& dest_bucket, std::string& d
                map<string, bufferlist>& attrs,  /* in/out */
                struct rgw_err *err)
 {
+  string& dest_bucket = dest_obj.bucket;
+  string& dest_oid = dest_obj.object;
+  string& src_bucket = src_obj.bucket;
+  string& src_oid = src_obj.object;
   int ret, r;
   char *data;
   off_t end = -1;
@@ -370,12 +378,12 @@ int RGWRados::copy_obj(std::string& id, std::string& dest_bucket, std::string& d
   time_t lastmod;
   map<string, bufferlist>::iterator iter;
 
-  RGW_LOG(5) << "Copy object " << src_bucket << ":" << src_obj << " => " << dest_bucket << ":" << dest_obj << dendl;
+  RGW_LOG(5) << "Copy object " << src_bucket << ":" << src_oid << " => " << dest_bucket << ":" << dest_oid << dendl;
 
   void *handle = NULL;
 
   map<string, bufferlist> attrset;
-  ret = prepare_get_obj(src_bucket, src_obj, src_obj, 0, &end, &attrset,
+  ret = prepare_get_obj(src_obj, src_oid, 0, &end, &attrset,
                 mod_ptr, unmod_ptr, &lastmod, if_match, if_nomatch, &total_len, &handle, err);
 
   if (ret < 0)
@@ -383,13 +391,13 @@ int RGWRados::copy_obj(std::string& id, std::string& dest_bucket, std::string& d
 
   off_t ofs = 0;
   do {
-    ret = get_obj(&handle, src_bucket, src_obj, src_obj, &data, ofs, end);
+    ret = get_obj(&handle, src_obj, src_oid, &data, ofs, end);
     if (ret < 0)
       return ret;
 
     // In the first call to put_obj_data, we pass ofs == -1 so that it will do
     // a write_full, wiping out whatever was in the object before this
-    r = put_obj_data(id, dest_bucket, dest_obj, dest_obj, data,
+    r = put_obj_data(id, dest_obj, dest_oid, data,
                     ((ofs == 0) ? -1 : ofs), ret, NULL);
     free(data);
     if (r < 0)
@@ -403,7 +411,7 @@ int RGWRados::copy_obj(std::string& id, std::string& dest_bucket, std::string& d
   }
   attrs = attrset;
 
-  ret = put_obj_meta(id, dest_bucket, dest_obj, dest_obj, mtime, attrs, false);
+  ret = put_obj_meta(id, dest_obj, dest_oid, mtime, attrs, false);
 
   finish_get_obj(&handle);
 
@@ -454,8 +462,10 @@ int RGWRados::delete_bucket(std::string& id, std::string& bucket)
  * obj: name of the object to delete
  * Returns: 0 on success, -ERR# otherwise.
  */
-int RGWRados::delete_obj(std::string& id, std::string& bucket, std::string& oid)
+int RGWRados::delete_obj(std::string& id, rgw_obj& obj)
 {
+  std::string& bucket = obj.bucket;
+  std::string& oid = obj.object;
   librados::IoCtx io_ctx;
   int r = open_bucket_ctx(bucket, io_ctx);
   if (r < 0)
@@ -476,12 +486,14 @@ int RGWRados::delete_obj(std::string& id, std::string& bucket, std::string& oid)
  * dest: bufferlist to store the result in
  * Returns: 0 on success, -ERR# otherwise.
  */
-int RGWRados::get_attr(std::string& bucket, std::string& obj, std::string& loc,
+int RGWRados::get_attr(rgw_obj& obj, std::string& loc,
                        const char *name, bufferlist& dest)
 {
+  std::string& bucket = obj.bucket;
+  std::string& oid = obj.object;
   librados::IoCtx io_ctx;
   string actual_bucket = bucket;
-  string actual_obj = obj;
+  string actual_obj = oid;
 
   if (actual_obj.size() == 0) {
     actual_obj = bucket;
@@ -509,9 +521,10 @@ int RGWRados::get_attr(std::string& bucket, std::string& obj, std::string& loc,
  * bl: the contents of the attr
  * Returns: 0 on success, -ERR# otherwise.
  */
-int RGWRados::set_attr(std::string& bucket, std::string& oid,
-                       const char *name, bufferlist& bl)
+int RGWRados::set_attr(rgw_obj& obj, const char *name, bufferlist& bl)
 {
+  std::string& bucket = obj.bucket;
+  std::string& oid = obj.object;
   librados::IoCtx io_ctx;
   string actual_bucket = bucket;
   string actual_obj = oid;
@@ -555,7 +568,7 @@ int RGWRados::set_attr(std::string& bucket, std::string& oid,
  *          (if get_data==true) length of read data,
  *          (if get_data==false) length of the object
  */
-int RGWRados::prepare_get_obj(std::string& bucket, std::string& oid, std::string& loc,
+int RGWRados::prepare_get_obj(rgw_obj& obj, std::string& loc,
             off_t ofs, off_t *end,
             map<string, bufferlist> *attrs,
             const time_t *mod_ptr,
@@ -567,6 +580,8 @@ int RGWRados::prepare_get_obj(std::string& bucket, std::string& oid, std::string
             void **handle,
             struct rgw_err *err)
 {
+  std::string& bucket = obj.bucket;
+  std::string& oid = obj.object;
   int r = -EINVAL;
   uint64_t size;
   bufferlist etag;
@@ -629,7 +644,7 @@ int RGWRados::prepare_get_obj(std::string& bucket, std::string& oid, std::string
     }
   }
   if (if_match || if_nomatch) {
-    r = get_attr(bucket, oid, loc, RGW_ATTR_ETAG, etag);
+    r = get_attr(obj, loc, RGW_ATTR_ETAG, etag);
     if (r < 0)
       goto done_err;
 
@@ -669,9 +684,12 @@ done_err:
   return r;
 }
 
-int RGWRados::clone_range(std::string& bucket, std::string& dst_oid, off_t dst_ofs,
-                          std::string& src_oid, off_t src_ofs, size_t size, std::string& loc)
+int RGWRados::clone_range(rgw_obj& dst_obj, off_t dst_ofs,
+                          rgw_obj& src_obj, off_t src_ofs, size_t size, std::string& loc)
 {
+  std::string& bucket = dst_obj.bucket;
+  std::string& dst_oid = dst_obj.object;
+  std::string& src_oid = src_obj.object;
   librados::IoCtx io_ctx;
 
   int r = open_bucket_ctx(bucket, io_ctx);
@@ -685,9 +703,11 @@ int RGWRados::clone_range(std::string& bucket, std::string& dst_oid, off_t dst_o
 
 
 int RGWRados::get_obj(void **handle,
-            std::string& bucket, std::string& oid, string& loc,
+            rgw_obj& obj, string& loc,
             char **data, off_t ofs, off_t end)
 {
+  std::string& bucket = obj.bucket;
+  std::string& oid = obj.object;
   uint64_t len;
   bufferlist bl;
 
@@ -730,8 +750,10 @@ void RGWRados::finish_get_obj(void **handle)
 }
 
 /* a simple object read */
-int RGWRados::read(std::string& bucket, std::string& oid, off_t ofs, size_t size, bufferlist& bl)
+int RGWRados::read(rgw_obj& obj, off_t ofs, size_t size, bufferlist& bl)
 {
+  std::string& bucket = obj.bucket;
+  std::string& oid = obj.object;
   librados::IoCtx io_ctx;
   int r = open_bucket_ctx(bucket, io_ctx);
   if (r < 0)
@@ -740,20 +762,24 @@ int RGWRados::read(std::string& bucket, std::string& oid, off_t ofs, size_t size
   return r;
 }
 
-int RGWRados::obj_stat(std::string& bucket, std::string& obj, uint64_t *psize, time_t *pmtime)
+int RGWRados::obj_stat(rgw_obj& obj, uint64_t *psize, time_t *pmtime)
 {
+  std::string& bucket = obj.bucket;
+  std::string& oid = obj.object;
   librados::IoCtx io_ctx;
   int r = open_bucket_ctx(bucket, io_ctx);
   if (r < 0)
     return r;
   if (r < 0)
     return r;
-  r = io_ctx.stat(obj, psize, pmtime);
+  r = io_ctx.stat(oid, psize, pmtime);
   return r;
 }
 
-int RGWRados::tmap_set(std::string& bucket, std::string& obj, std::string& key, bufferlist& bl)
+int RGWRados::tmap_set(rgw_obj& obj, std::string& key, bufferlist& bl)
 {
+  std::string& bucket = obj.bucket;
+  std::string& oid = obj.object;
   bufferlist cmdbl, emptybl;
   __u8 c = CEPH_OSD_TMAP_SET;
 
@@ -761,19 +787,21 @@ int RGWRados::tmap_set(std::string& bucket, std::string& obj, std::string& key,
   ::encode(key, cmdbl);
   ::encode(bl, cmdbl);
 
-  RGW_LOG(15) << "tmap_set bucket=" << bucket << " obj=" << obj << " key=" << key << dendl;
+  RGW_LOG(15) << "tmap_set bucket=" << bucket << " oid=" << oid << " key=" << key << dendl;
 
   librados::IoCtx io_ctx;
   int r = open_bucket_ctx(bucket, io_ctx);
   if (r < 0)
     return r;
-  r = io_ctx.tmap_update(obj, cmdbl);
+  r = io_ctx.tmap_update(oid, cmdbl);
 
   return r;
 }
 
-int RGWRados::tmap_create(std::string& bucket, std::string& obj, std::string& key, bufferlist& bl)
+int RGWRados::tmap_create(rgw_obj& obj, std::string& key, bufferlist& bl)
 {
+  std::string& bucket = obj.bucket;
+  std::string& oid = obj.object;
   bufferlist cmdbl, emptybl;
   __u8 c = CEPH_OSD_TMAP_CREATE;
 
@@ -785,12 +813,14 @@ int RGWRados::tmap_create(std::string& bucket, std::string& obj, std::string& ke
   int r = open_bucket_ctx(bucket, io_ctx);
   if (r < 0)
     return r;
-  r = io_ctx.tmap_update(obj, cmdbl);
+  r = io_ctx.tmap_update(oid, cmdbl);
   return r;
 }
 
-int RGWRados::tmap_del(std::string& bucket, std::string& obj, std::string& key)
+int RGWRados::tmap_del(rgw_obj& obj, std::string& key)
 {
+  std::string& bucket = obj.bucket;
+  std::string& oid = obj.object;
   bufferlist cmdbl;
   __u8 c = CEPH_OSD_TMAP_RM;
 
@@ -801,7 +831,7 @@ int RGWRados::tmap_del(std::string& bucket, std::string& obj, std::string& key)
   int r = open_bucket_ctx(bucket, io_ctx);
   if (r < 0)
     return r;
-  r = io_ctx.tmap_update(obj, cmdbl);
+  r = io_ctx.tmap_update(oid, cmdbl);
   return r;
 }
 int RGWRados::update_containers_stats(map<string, RGWBucketEnt>& m)
@@ -836,8 +866,10 @@ int RGWRados::update_containers_stats(map<string, RGWBucketEnt>& m)
   return count;
 }
 
-int RGWRados::append_async(std::string& bucket, std::string& oid, size_t size, bufferlist& bl)
+int RGWRados::append_async(rgw_obj& obj, size_t size, bufferlist& bl)
 {
+  std::string& bucket = obj.bucket;
+  std::string& oid = obj.object;
   librados::IoCtx io_ctx;
   int r = open_bucket_ctx(bucket, io_ctx);
   if (r < 0)

diff --git a/src/rgw/rgw_rados.h b/src/rgw/rgw_rados.h
index 30c47b2e7403809529f4391b7f923a4ba4181249..8cb7592fce85f4b6c1546d3b96c304e18eb09fb7 100644 (file)
--- a/src/rgw/rgw_rados.h
+++ b/src/rgw/rgw_rados.h
@@ -42,15 +42,15 @@ public:
   virtual int create_bucket(std::string& id, std::string& bucket, map<std::string,bufferlist>& attrs, uint64_t auid=0);
 
   /** Write/overwrite an object to the bucket storage. */
-  virtual int put_obj_meta(std::string& id, std::string& bucket, std::string& obj, std::string& loc, time_t *mtime,
+  virtual int put_obj_meta(std::string& id, rgw_obj& obj, std::string& loc, time_t *mtime,
               map<std::string, bufferlist>& attrs, bool exclusive);
-  virtual int put_obj_data(std::string& id, std::string& bucket, std::string& obj, std::string& loc, const char *data,
+  virtual int put_obj_data(std::string& id, rgw_obj& obj, std::string& loc, const char *data,
               off_t ofs, size_t len, time_t *mtime);
-  virtual int clone_range(std::string& bucket, std::string& dst_oid, off_t dst_ofs,
-                          std::string& src_oid, off_t src_ofs, size_t size, std::string& loc);
+  virtual int clone_range(rgw_obj& dst_obj, off_t dst_ofs,
+                          rgw_obj& src_obj, off_t src_ofs, size_t size, std::string& loc);
   /** Copy an object, with many extra options */
-  virtual int copy_obj(std::string& id, std::string& dest_bucket, std::string& dest_obj,
-               std::string& src_bucket, std::string& src_obj,
+  virtual int copy_obj(std::string& id, rgw_obj& dest_obj,
+               rgw_obj& src_obj,
                time_t *mtime,
                const time_t *mod_ptr,
                const time_t *unmod_ptr,
@@ -62,18 +62,17 @@ public:
   virtual int delete_bucket(std::string& id, std::string& bucket);
 
   /** Delete an object.*/
-  virtual int delete_obj(std::string& id, std::string& bucket, std::string& obj);
+  virtual int delete_obj(std::string& id, rgw_obj& src_obj);
 
   /** Get the attributes for an object.*/
-  virtual int get_attr(std::string& bucket, std::string& obj, std::string& loc,
+  virtual int get_attr(rgw_obj& obj, std::string& loc,
                const char *name, bufferlist& dest);
 
   /** Set an attr on an object. */
-  virtual int set_attr(std::string& bucket, std::string& obj,
-                       const char *name, bufferlist& bl);
+  virtual int set_attr(rgw_obj& obj, const char *name, bufferlist& bl);
 
   /** Get data about an object out of RADOS and into memory. */
-  virtual int prepare_get_obj(std::string& bucket, std::string& obj, std::string& loc,  
+  virtual int prepare_get_obj(rgw_obj& obj, std::string& loc,  
             off_t ofs, off_t *end,
             map<string, bufferlist> *attrs,
             const time_t *mod_ptr,
@@ -85,21 +84,21 @@ public:
             void **handle,
             struct rgw_err *err);
 
-  virtual int get_obj(void **handle, std::string& bucket, std::string& oid, std::string& loc,
+  virtual int get_obj(void **handle, rgw_obj& obj, std::string& loc,
             char **data, off_t ofs, off_t end);
 
   virtual void finish_get_obj(void **handle);
 
-  virtual int read(std::string& bucket, std::string& oid, off_t ofs, size_t size, bufferlist& bl);
+  virtual int read(rgw_obj& obj, off_t ofs, size_t size, bufferlist& bl);
 
-  virtual int obj_stat(std::string& bucket, std::string& obj, uint64_t *psize, time_t *pmtime);
+  virtual int obj_stat(rgw_obj& obj, uint64_t *psize, time_t *pmtime);
 
   virtual bool supports_tmap() { return true; }
-  virtual int tmap_set(std::string& bucket, std::string& obj, std::string& key, bufferlist& bl);
-  virtual int tmap_create(std::string& bucket, std::string& obj, std::string& key, bufferlist& bl);
-  virtual int tmap_del(std::string& bucket, std::string& obj, std::string& key);
+  virtual int tmap_set(rgw_obj& obj, std::string& key, bufferlist& bl);
+  virtual int tmap_create(rgw_obj& obj, std::string& key, bufferlist& bl);
+  virtual int tmap_del(rgw_obj& obj, std::string& key);
   virtual int update_containers_stats(map<string, RGWBucketEnt>& m);
-  virtual int append_async(std::string& bucket, std::string& oid, size_t size, bufferlist& bl);
+  virtual int append_async(rgw_obj& obj, size_t size, bufferlist& bl);
 };
 
 #endif

diff --git a/src/rgw/rgw_user.cc b/src/rgw/rgw_user.cc
index 45cda0d12e06ce410075caffef6c974a2632d22f..73bb535f32f4872f78f55c5a00c5977c56247e8a 100644 (file)
--- a/src/rgw/rgw_user.cc
+++ b/src/rgw/rgw_user.cc
@@ -35,12 +35,16 @@ static int put_obj(string& uid, string& bucket, string& oid, const char *data, s
 {
   map<string,bufferlist> attrs;
 
-  int ret = rgwstore->put_obj(uid, bucket, oid, oid, data, size, NULL, attrs);
+  rgw_obj obj;
+  obj.bucket = bucket;
+  obj.object = oid;
+
+  int ret = rgwstore->put_obj(uid, obj, oid, data, size, NULL, attrs);
 
   if (ret == -ENOENT) {
     ret = rgwstore->create_bucket(uid, bucket, attrs);
     if (ret >= 0)
-      ret = rgwstore->put_obj(uid, bucket, oid, oid, data, size, NULL, attrs);
+      ret = rgwstore->put_obj(uid, obj, oid, data, size, NULL, attrs);
   }
 
   return ret;
@@ -124,13 +128,14 @@ int rgw_get_user_info_from_index(string& key, string& bucket, RGWUserInfo& info)
   void *handle = NULL;
   bufferlist::iterator iter;
   int request_len = READ_CHUNK_LEN;
-  ret = rgwstore->prepare_get_obj(bucket, key, key, 0, NULL, NULL, NULL,
+  rgw_obj obj(bucket, key);
+  ret = rgwstore->prepare_get_obj(obj, key, 0, NULL, NULL, NULL,
                                   NULL, NULL, NULL, NULL, NULL, &handle, &err);
   if (ret < 0)
     return ret;
 
   do {
-    ret = rgwstore->get_obj(&handle, bucket, key, key, &data, 0, request_len - 1);
+    ret = rgwstore->get_obj(&handle, obj, key, &data, 0, request_len - 1);
     if (ret < 0)
       goto done;
     if (ret < request_len)
@@ -198,7 +203,8 @@ static void get_buckets_obj(string& user_id, string& buckets_obj_id)
 static int rgw_read_buckets_from_attr(string& user_id, RGWUserBuckets& buckets)
 {
   bufferlist bl;
-  int ret = rgwstore->get_attr(ui_uid_bucket, user_id, user_id, RGW_ATTR_BUCKETS, bl);
+  rgw_obj obj(ui_uid_bucket, user_id);
+  int ret = rgwstore->get_attr(obj, user_id, RGW_ATTR_BUCKETS, bl);
   if (ret)
     return ret;
 
@@ -233,9 +239,10 @@ int rgw_read_user_buckets(string user_id, RGWUserBuckets& buckets, bool need_sta
     bufferlist bl;
 #define LARGE_ENOUGH_LEN (4096 * 1024)
     size_t len = LARGE_ENOUGH_LEN;
+    rgw_obj obj(ui_uid_bucket, buckets_obj_id);
 
     do {
-      ret = rgwstore->read(ui_uid_bucket, buckets_obj_id, 0, len, bl);
+      ret = rgwstore->read(obj, 0, len, bl);
       if (ret == -ENOENT) {
         /* try to read the old format */
         ret = rgw_read_buckets_from_attr(user_id, buckets);
@@ -304,7 +311,9 @@ int rgw_write_buckets_attr(string user_id, RGWUserBuckets& buckets)
   bufferlist bl;
   buckets.encode(bl);
 
-  int ret = rgwstore->set_attr(ui_uid_bucket, user_id, RGW_ATTR_BUCKETS, bl);
+  rgw_obj obj(ui_uid_bucket, user_id);
+
+  int ret = rgwstore->set_attr(obj, RGW_ATTR_BUCKETS, bl);
 
   return ret;
 }
@@ -325,7 +334,8 @@ int rgw_add_bucket(string user_id, string bucket_name)
     string buckets_obj_id;
     get_buckets_obj(user_id, buckets_obj_id);
 
-    ret = rgwstore->tmap_create(ui_uid_bucket, buckets_obj_id, bucket_name, bl);
+    rgw_obj obj(ui_uid_bucket, buckets_obj_id);
+    ret = rgwstore->tmap_create(obj, bucket_name, bl);
     if (ret < 0) {
       RGW_LOG(0) << "error adding bucket to directory: "
                 << cpp_strerror(-ret)<< dendl;
@@ -365,7 +375,8 @@ int rgw_remove_bucket(string user_id, string bucket_name)
     string buckets_obj_id;
     get_buckets_obj(user_id, buckets_obj_id);
 
-    ret = rgwstore->tmap_del(ui_uid_bucket, buckets_obj_id, bucket_name);
+    rgw_obj obj(ui_uid_bucket, buckets_obj_id);
+    ret = rgwstore->tmap_del(obj, bucket_name);
     if (ret < 0) {
       RGW_LOG(0) << "error removing bucket from directory: "
                 << cpp_strerror(-ret)<< dendl;
@@ -386,7 +397,8 @@ int rgw_remove_bucket(string user_id, string bucket_name)
 
 int rgw_remove_key_storage(RGWAccessKey& access_key)
 {
-  rgwstore->delete_obj(access_key.id, ui_key_bucket, access_key.id);
+  rgw_obj obj(ui_key_bucket, access_key.id);
+  rgwstore->delete_obj(access_key.id, obj);
   return 0;
 }
 
@@ -404,14 +416,17 @@ int rgw_delete_user(RGWUserInfo& info) {
        i != buckets.end();
        ++i) {
     string bucket_name = i->first;
-    rgwstore->delete_obj(info.user_id, rgw_root_bucket, bucket_name);
+    rgw_obj obj(rgw_root_bucket, bucket_name);
+    rgwstore->delete_obj(info.user_id, obj);
   }
   map<string, RGWAccessKey>::iterator kiter = info.access_keys.begin();
   for (; kiter != info.access_keys.end(); ++kiter)
     rgw_remove_key_storage(kiter->second);
 
-  rgwstore->delete_obj(info.user_id, ui_uid_bucket, info.user_id);
-  rgwstore->delete_obj(info.user_id, ui_email_bucket, info.user_email);
+  rgw_obj uid_obj(ui_uid_bucket, info.user_id);
+  rgwstore->delete_obj(info.user_id, uid_obj);
+  rgw_obj email_obj(ui_email_bucket, info.user_email);
+  rgwstore->delete_obj(info.user_id, email_obj);
   return 0;
 }