rgw/acl: use rgw_owner for ACLOwner

Signed-off-by: Casey Bodley <cbodley@redhat.com>

diff --git a/doc/radosgw/lua-scripting.rst b/doc/radosgw/lua-scripting.rst
index eafde154e25c0e02999836084e412b361cfa2abb..f7bc530248d995656c8ba51c97be55b00cec3eec 100644 (file)
--- a/doc/radosgw/lua-scripting.rst
+++ b/doc/radosgw/lua-scripting.rst
@@ -200,11 +200,7 @@ Request Fields
 +----------------------------------------------------+----------+--------------------------------------------------------------+----------+-----------+----------+
 | ``Request.Bucket.PlacementRule.StorageClass``      | string   | bucket placement rule storage class                          | no       | no        | no       |
 +----------------------------------------------------+----------+--------------------------------------------------------------+----------+-----------+----------+
-| ``Request.Bucket.User``                            | table    | bucket owner                                                 | no       | no        | yes      |
-+----------------------------------------------------+----------+--------------------------------------------------------------+----------+-----------+----------+
-| ``Request.Bucket.User.Tenant``                     | string   | bucket owner tenant                                          | no       | no        | no       |
-+----------------------------------------------------+----------+--------------------------------------------------------------+----------+-----------+----------+
-| ``Request.Bucket.User.Id``                         | string   | bucket owner id                                              | no       | no        | no       |
+| ``Request.Bucket.User``                            | string   | owning user/account id                                       | no       | no        | yes      |
 +----------------------------------------------------+----------+--------------------------------------------------------------+----------+-----------+----------+
 | ``Request.Object``                                 | table    | info on the object                                           | no       | no        | yes      |
 +----------------------------------------------------+----------+--------------------------------------------------------------+----------+-----------+----------+
@@ -230,7 +226,7 @@ Request Fields
 +----------------------------------------------------+----------+--------------------------------------------------------------+----------+-----------+----------+
 | ``Request.ObjectOwner.DisplayName``                | string   | object owner display name                                    | no       | no        | no       |
 +----------------------------------------------------+----------+--------------------------------------------------------------+----------+-----------+----------+
-| ``Request.ObjectOwner.User``                       | table    | object user. See: ``Request.Bucket.User``                    | no       | no        | no       |
+| ``Request.ObjectOwner.User``                       | string   | owning user/account id. See: ``Request.Bucket.User``         | no       | no        | yes      |
 +----------------------------------------------------+----------+--------------------------------------------------------------+----------+-----------+----------+
 | ``Request.ZoneGroup.Name``                         | string   | name of zone group                                           | no       | no        | no       |
 +----------------------------------------------------+----------+--------------------------------------------------------------+----------+-----------+----------+
@@ -248,11 +244,7 @@ Request Fields
 +----------------------------------------------------+----------+--------------------------------------------------------------+----------+-----------+----------+
 | ``Request.UserAcl.Grants["<name>"].Type``          | integer  | user ACL grant type                                          | no       | no        | no       |
 +----------------------------------------------------+----------+--------------------------------------------------------------+----------+-----------+----------+
-| ``Request.UserAcl.Grants["<name>"].User``          | table    | user ACL grant user                                          | no       | no        | yes      |
-+----------------------------------------------------+----------+--------------------------------------------------------------+----------+-----------+----------+
-| ``Request.UserAcl.Grants["<name>"].User.Tenant``   | table    | user ACL grant user tenant                                   | no       | no        | no       |
-+----------------------------------------------------+----------+--------------------------------------------------------------+----------+-----------+----------+
-| ``Request.UserAcl.Grants["<name>"].User.Id``       | table    | user ACL grant user id                                       | no       | no        | no       |
+| ``Request.UserAcl.Grants["<name>"].User``          | string   | user ACL grant user/account id                               | no       | no        | no       |
 +----------------------------------------------------+----------+--------------------------------------------------------------+----------+-----------+----------+
 | ``Request.UserAcl.Grants["<name>"].GroupType``     | integer  | user ACL grant group type                                    | no       | no        | yes      |
 +----------------------------------------------------+----------+--------------------------------------------------------------+----------+-----------+----------+

diff --git a/src/rgw/rgw_acl.cc b/src/rgw/rgw_acl.cc
index 4369bedfc76b488a9b9e2ad95b76796a1306ce59..f8a2eb8e5467cf27571d70b9a967e742149c1fc1 100644 (file)
--- a/src/rgw/rgw_acl.cc
+++ b/src/rgw/rgw_acl.cc
@@ -6,6 +6,7 @@
 #include <iostream>
 #include <map>
 
+#include "include/function2.hpp"
 #include "include/types.h"
 
 #include "common/Formatter.h"
@@ -72,7 +73,7 @@ void RGWAccessControlList::register_grant(const ACLGrant& grant)
   ACLPermission perm = grant.get_permission();
 
   if (const auto* user = grant.get_user(); user) {
-    acl_user_map[user->id.to_str()] |= perm.get_permissions();
+    acl_user_map[to_string(user->id)] |= perm.get_permissions();
   } else if (const auto* email = grant.get_email(); email) {
     acl_user_map[email->address] |= perm.get_permissions();
   } else if (const auto* group = grant.get_group(); group) {
@@ -92,7 +93,7 @@ void RGWAccessControlList::add_grant(const ACLGrant& grant)
 {
   std::string id;
   if (const auto* user = grant.get_user(); user) {
-    id = user->id.to_str();
+    id = to_string(user->id);
   } else if (const auto* email = grant.get_email(); email) {
     id = email->address;
   } // other types share the empty key in the grant multimap
@@ -100,11 +101,11 @@ void RGWAccessControlList::add_grant(const ACLGrant& grant)
   register_grant(grant);
 }
 
-void RGWAccessControlList::remove_canon_user_grant(const rgw_user& user_id)
+void RGWAccessControlList::remove_canon_user_grant(const rgw_owner& owner)
 {
-  const std::string& key = user_id.to_str();
-  grant_map.erase(key);
-  acl_user_map.erase(key);
+  const std::string& id = to_string(owner);
+  grant_map.erase(id);
+  acl_user_map.erase(id);
 }
 
 uint32_t RGWAccessControlList::get_perm(const DoutPrefixProvider* dpp, 
@@ -245,6 +246,14 @@ bool RGWAccessControlPolicy::is_public(const DoutPrefixProvider *dpp) const
 
 }
 
+bool ACLOwner::empty() const
+{
+  return std::visit(fu2::overload(
+      [] (const rgw_user& uid) { return uid.empty(); },
+      [] (const rgw_account_id& aid) { return aid.empty(); }
+      ), id);
+}
+
 void ACLPermission::generate_test_instances(list<ACLPermission*>& o)
 {
   ACLPermission *p = new ACLPermission;
@@ -346,7 +355,7 @@ void RGWAccessControlPolicy::generate_test_instances(list<RGWAccessControlPolicy
     RGWAccessControlList *l = *iter;
     p->acl = *l;
 
-    p->owner.id.id = "rgw";
+    p->owner.id = rgw_user{"rgw"};
     p->owner.display_name = "radosgw";
 
     o.push_back(p);
@@ -394,14 +403,14 @@ void RGWAccessControlList::dump(Formatter *f) const
 
 void ACLOwner::dump(Formatter *f) const
 {
-  encode_json("id", id.to_str(), f);
+  encode_json("id", to_string(id), f);
   encode_json("display_name", display_name, f);
 }
 
 void ACLOwner::decode_json(JSONObj *obj) {
   string id_str;
   JSONDecoder::decode_json("id", id_str, obj);
-  id.from_str(id_str);
+  id = parse_owner(id_str);
   JSONDecoder::decode_json("display_name", display_name, obj);
 }
 

diff --git a/src/rgw/rgw_acl.h b/src/rgw/rgw_acl.h
index e2887a7049b6e3163315ac61705ea1aee474188d..fdc9961e8dc9bc8ab6c23cec334ff292de966a89 100644 (file)
--- a/src/rgw/rgw_acl.h
+++ b/src/rgw/rgw_acl.h
@@ -18,7 +18,7 @@
 
 // acl grantee types
 struct ACLGranteeCanonicalUser {
-  rgw_user id;
+  rgw_owner id;
   std::string name;
 
   friend auto operator<=>(const ACLGranteeCanonicalUser&,
@@ -90,7 +90,7 @@ public:
     encode(type, bl);
 
     if (const ACLGranteeCanonicalUser* user = get_user(); user) {
-      encode(user->id.to_str(), bl);
+      encode(to_string(user->id), bl);
     } else {
       encode(std::string{}, bl); // encode empty id
     }
@@ -133,7 +133,7 @@ public:
     ACLGranteeCanonicalUser user;
     std::string s;
     decode(s, bl);
-    user.id.from_str(s);
+    user.id = parse_owner(s);
 
     std::string uri;
     decode(uri, bl);
@@ -180,7 +180,7 @@ public:
 
   static ACLGroupTypeEnum uri_to_group(std::string_view uri);
 
-  void set_canon(const rgw_user& id, const std::string& name, uint32_t perm) {
+  void set_canon(const rgw_owner& id, const std::string& name, uint32_t perm) {
     grantee = ACLGranteeCanonicalUser{id, name};
     permission.set_permissions(perm);
   }
@@ -330,13 +330,15 @@ public:
   void dump(Formatter *f) const;
   static void generate_test_instances(std::list<RGWAccessControlList*>& o);
 
+  bool empty() const { return grant_map.empty(); }
+
   void add_grant(const ACLGrant& grant);
-  void remove_canon_user_grant(const rgw_user& user_id);
+  void remove_canon_user_grant(const rgw_owner& user_id);
 
   ACLGrantMap& get_grant_map() { return grant_map; }
   const ACLGrantMap& get_grant_map() const { return grant_map; }
 
-  void create_default(const rgw_user& id, const std::string& name) {
+  void create_default(const rgw_owner& id, const std::string& name) {
     acl_user_map.clear();
     acl_group_map.clear();
     referer_list.clear();
@@ -352,13 +354,12 @@ public:
 WRITE_CLASS_ENCODER(RGWAccessControlList)
 
 struct ACLOwner {
-  rgw_user id;
+  rgw_owner id;
   std::string display_name;
 
   void encode(bufferlist& bl) const {
     ENCODE_START(3, 2, bl);
-    std::string s;
-    id.to_str(s);
+    const std::string s = to_string(id);
     encode(s, bl);
     encode(display_name, bl);
     ENCODE_FINISH(bl);
@@ -367,7 +368,7 @@ struct ACLOwner {
     DECODE_START_LEGACY_COMPAT_LEN(3, 2, 2, bl);
     std::string s;
     decode(s, bl);
-    id.from_str(s);
+    id = parse_owner(s);
     decode(display_name, bl);
     DECODE_FINISH(bl);
   }
@@ -375,6 +376,8 @@ struct ACLOwner {
   void decode_json(JSONObj *obj);
   static void generate_test_instances(std::list<ACLOwner*>& o);
 
+  bool empty() const;
+
   auto operator<=>(const ACLOwner&) const = default;
 };
 WRITE_CLASS_ENCODER(ACLOwner)
@@ -418,11 +421,13 @@ public:
     DECODE_FINISH(bl);
   }
 
+  bool empty() const { return acl.empty() && owner.empty(); }
+
   void set_owner(const ACLOwner& o) { owner = o; }
   const ACLOwner& get_owner() const { return owner; }
   ACLOwner& get_owner() { return owner; }
 
-  void create_default(const rgw_user& id, const std::string& name) {
+  void create_default(const rgw_owner& id, const std::string& name) {
     acl.create_default(id, name);
     owner.id = id;
     owner.display_name = name;

diff --git a/src/rgw/rgw_acl_s3.cc b/src/rgw/rgw_acl_s3.cc
index e45fb552aff601ce63ce39ed2d21bd851f5483d4..71114bb1bf896924b220119f9eac9a1da4060867 100644 (file)
--- a/src/rgw/rgw_acl_s3.cc
+++ b/src/rgw/rgw_acl_s3.cc
@@ -171,8 +171,7 @@ bool ACLOwner_S3::xml_end(const char *el) {
 
 void to_xml(const ACLOwner& o, std::ostream& out)
 {
-  string s;
-  o.id.to_str(s);
+  const std::string s = to_string(o.id);
   if (s.empty())
     return;
   out << "<Owner>" << "<ID>" << s << "</ID>";
@@ -366,7 +365,7 @@ static int parse_acl_header(const DoutPrefixProvider* dpp, rgw::sal::Driver* dri
 static int create_canned(const ACLOwner& owner, const ACLOwner& bucket_owner,
                          const string& canned_acl, RGWAccessControlList& acl)
 {
-  const rgw_user& bid = bucket_owner.id;
+  const rgw_owner& bid = bucket_owner.id;
   const std::string& bname = bucket_owner.display_name;
 
   /* owner gets full control */
@@ -600,7 +599,7 @@ int parse_policy(const DoutPrefixProvider* dpp, optional_yield y,
   }
 
   ACLOwner& owner = policy.get_owner();
-  owner.id = xml_owner->id;
+  owner.id = parse_owner(xml_owner->id);
   if (!xml_owner->display_name.empty()) {
     owner.display_name = xml_owner->display_name;
   } else {
@@ -641,7 +640,7 @@ int create_canned_acl(const ACLOwner& owner,
                       const std::string& canned_acl,
                       RGWAccessControlPolicy& policy)
 {
-  if (owner.id == rgw_user("anonymous")) {
+  if (owner.id == parse_owner("anonymous")) {
     policy.set_owner(bucket_owner);
   } else {
     policy.set_owner(owner);

diff --git a/src/rgw/rgw_acl_swift.cc b/src/rgw/rgw_acl_swift.cc
index 3f4191ab26a893cea6ffe703e81144be03728d2d..67e0daf5b72e29ca1a533ad24ceea7c73ca797bd 100644 (file)
--- a/src/rgw/rgw_acl_swift.cc
+++ b/src/rgw/rgw_acl_swift.cc
@@ -244,7 +244,7 @@ void format_container_acls(const RGWAccessControlPolicy& policy,
     std::string id;
     std::string url_spec;
     if (const auto user = grant.get_user(); user) {
-      id = user->id.to_str();
+      id = to_string(user->id);
     } else if (const auto group = grant.get_group(); group) {
       if (group->type == ACL_GROUP_ALL_USERS) {
         id = SWIFT_GROUP_ALL_USERS;
@@ -340,7 +340,7 @@ auto format_account_acl(const RGWAccessControlPolicy& policy)
       if (owner.id == user->id) {
         continue;
       }
-      id = user->id.to_str();
+      id = to_string(user->id);
     } else if (const auto group = grant.get_group(); group) {
       if (group->type != ACL_GROUP_ALL_USERS) {
         continue;

diff --git a/src/rgw/rgw_common.cc b/src/rgw/rgw_common.cc
index 8cdedd3671e9022481ff20f2ccff4d4a8a08f4f8..7a0bec1271b0c9848870cb799e0158f4a6d572ad 100644 (file)
--- a/src/rgw/rgw_common.cc
+++ b/src/rgw/rgw_common.cc
@@ -1190,7 +1190,7 @@ bool verify_user_permission_no_policy(const DoutPrefixProvider* dpp,
     return false;
 
   /* S3 doesn't support account ACLs, so user_acl will be uninitialized. */
-  if (user_acl.get_owner().id.empty())
+  if (user_acl.get_owner().empty())
     return true;
   
   return user_acl.verify_permission(dpp, *s->identity, perm, perm);

diff --git a/src/rgw/rgw_log.cc b/src/rgw/rgw_log.cc
index e3c463fcecc4ed9f571dbdc0372899b3cb49b9d3..169cac4dd4dd0bf3bb83ff7ea4de6811513106a6 100644 (file)
--- a/src/rgw/rgw_log.cc
+++ b/src/rgw/rgw_log.cc
@@ -200,21 +200,21 @@ static void log_usage(req_state *s, const string& op_name)
   if (!usage_logger)
     return;
 
-  rgw_user user;
-  rgw_user payer;
+  std::string user;
+  std::string payer;
   string bucket_name;
 
   bucket_name = s->bucket_name;
 
   if (!bucket_name.empty()) {
     bucket_name = s->bucket_name;
-    user = s->bucket_owner.id;
+    user = to_string(s->bucket_owner.id);
     if (!rgw::sal::Bucket::empty(s->bucket.get()) &&
        s->bucket->get_info().requester_pays) {
-      payer = s->user->get_id();
+      payer = s->user->get_id().to_str();
     }
   } else {
-    user = s->user->get_id();
+    user = to_string(s->owner.id);
   }
 
   bool error = s->err.is_err();
@@ -222,9 +222,7 @@ static void log_usage(req_state *s, const string& op_name)
     bucket_name = "-"; /* bucket not found, use the invalid '-' as bucket name */
   }
 
-  string u = user.to_str();
-  string p = payer.to_str();
-  rgw_usage_log_entry entry(u, p, bucket_name);
+  rgw_usage_log_entry entry(user, payer, bucket_name);
 
   uint64_t bytes_sent = ACCOUNTING_IO(s)->get_bytes_sent();
   uint64_t bytes_received = ACCOUNTING_IO(s)->get_bytes_received();
@@ -261,7 +259,7 @@ void rgw_format_ops_log_entry(struct rgw_log_entry& entry, Formatter *formatter)
     t.localtime(formatter->dump_stream("time_local"));
   }
   formatter->dump_string("remote_addr", entry.remote_addr);
-  string obj_owner = entry.object_owner.to_str();
+  string obj_owner = to_string(entry.object_owner);
   if (obj_owner.length())
     formatter->dump_string("object_owner", obj_owner);
   formatter->dump_string("user", entry.user);
@@ -679,8 +677,8 @@ int rgw_log_op(RGWREST* const rest, req_state *s, const RGWOp* op, OpsLogSink *o
 void rgw_log_entry::generate_test_instances(list<rgw_log_entry*>& o)
 {
   rgw_log_entry *e = new rgw_log_entry;
-  e->object_owner = "object_owner";
-  e->bucket_owner = "bucket_owner";
+  e->object_owner = parse_owner("object_owner");
+  e->bucket_owner = parse_owner("bucket_owner");
   e->bucket = "bucket";
   e->remote_addr = "1.2.3.4";
   e->user = "user";
@@ -702,8 +700,8 @@ void rgw_log_entry::generate_test_instances(list<rgw_log_entry*>& o)
 
 void rgw_log_entry::dump(Formatter *f) const
 {
-  f->dump_string("object_owner", object_owner.to_str());
-  f->dump_string("bucket_owner", bucket_owner.to_str());
+  f->dump_string("object_owner", to_string(object_owner));
+  f->dump_string("bucket_owner", to_string(bucket_owner));
   f->dump_string("bucket", bucket);
   f->dump_stream("time") << time;
   f->dump_string("remote_addr", remote_addr);

diff --git a/src/rgw/rgw_log.h b/src/rgw/rgw_log.h
index 1dd79273e6a19514bf7856ded3d9a7485a927293..d8303f65d9dcf21e426a5dc28efe8e594b26f283 100644 (file)
--- a/src/rgw/rgw_log.h
+++ b/src/rgw/rgw_log.h
@@ -6,6 +6,7 @@
 #include <boost/container/flat_map.hpp>
 #include "rgw_common.h"
 #include "common/OutputDataSocket.h"
+#include "common/versioned_variant.h"
 #include <vector>
 #include <fstream>
 #include "rgw_sal_fwd.h"
@@ -75,8 +76,8 @@ struct rgw_log_entry {
   using headers_map = boost::container::flat_map<std::string, std::string>;
   using Clock = req_state::Clock;
 
-  rgw_user object_owner;
-  rgw_user bucket_owner;
+  rgw_owner object_owner;
+  rgw_owner bucket_owner;
   std::string bucket;
   Clock::time_point time;
   std::string remote_addr;
@@ -104,8 +105,11 @@ struct rgw_log_entry {
 
   void encode(bufferlist &bl) const {
     ENCODE_START(14, 5, bl);
-    encode(object_owner.id, bl);
-    encode(bucket_owner.id, bl);
+    // old object/bucket owner ids, encoded in full in v8
+    std::string empty_owner_id;
+    encode(empty_owner_id, bl);
+    encode(empty_owner_id, bl);
+
     encode(bucket, bl);
     encode(time, bl);
     encode(remote_addr, bl);
@@ -123,8 +127,9 @@ struct rgw_log_entry {
     encode(bytes_received, bl);
     encode(bucket_id, bl);
     encode(obj, bl);
-    encode(object_owner, bl);
-    encode(bucket_owner, bl);
+    // transparently converted from rgw_user to rgw_owner
+    ceph::converted_variant::encode(object_owner, bl);
+    ceph::converted_variant::encode(bucket_owner, bl);
     encode(x_headers, bl);
     encode(trans_id, bl);
     encode(token_claims, bl);
@@ -137,9 +142,11 @@ struct rgw_log_entry {
   }
   void decode(bufferlist::const_iterator &p) {
     DECODE_START_LEGACY_COMPAT_LEN(14, 5, 5, p);
-    decode(object_owner.id, p);
+    std::string object_owner_id;
+    std::string bucket_owner_id;
+    decode(object_owner_id, p);
     if (struct_v > 3)
-      decode(bucket_owner.id, p);
+      decode(bucket_owner_id, p);
     decode(bucket, p);
     decode(time, p);
     decode(remote_addr, p);
@@ -176,8 +183,12 @@ struct rgw_log_entry {
       decode(obj, p);
     }
     if (struct_v >= 8) {
-      decode(object_owner, p);
-      decode(bucket_owner, p);
+      // transparently converted from rgw_user to rgw_owner
+      ceph::converted_variant::decode(object_owner, p);
+      ceph::converted_variant::decode(bucket_owner, p);
+    } else {
+      object_owner = parse_owner(object_owner_id);
+      bucket_owner = parse_owner(bucket_owner_id);
     }
     if (struct_v >= 9) {
       decode(x_headers, p);

diff --git a/src/rgw/rgw_lua_request.cc b/src/rgw/rgw_lua_request.cc
index a36aad666f460eaa70e51209b52a6f22a9cb6084..d430620ac0d1452846eb9195e6cb3026670aac8b 100644 (file)
--- a/src/rgw/rgw_lua_request.cc
+++ b/src/rgw/rgw_lua_request.cc
@@ -262,7 +262,7 @@ struct OwnerMetaTable : public EmptyMetaTable {
     if (strcasecmp(index, "DisplayName") == 0) {
       pushstring(L, owner->display_name);
     } else if (strcasecmp(index, "User") == 0) {
-      create_metatable<UserMetaTable>(L, name, index, false, &owner->id);
+      pushstring(L, to_string(owner->id));
     } else {
       return error_unknown_field(L, index, name);
     }
@@ -365,8 +365,7 @@ struct GrantMetaTable : public EmptyMetaTable {
       lua_pushinteger(L, grant->get_type().get_type());
     } else if (strcasecmp(index, "User") == 0) {
       if (const auto user = grant->get_user(); user) {
-        create_metatable<UserMetaTable>(L, name, index, false, 
-            const_cast<rgw_user*>(&user->id));
+        pushstring(L, to_string(user->id));
       } else {
         lua_pushnil(L);
       }

diff --git a/src/rgw/rgw_op.cc b/src/rgw/rgw_op.cc
index 5366681f63dc446ef33bdc2b4ec1a20d238896f8..0cf888b7fffd9d49bad0ea7820ff7d1c1ad6b5f7 100644 (file)
--- a/src/rgw/rgw_op.cc
+++ b/src/rgw/rgw_op.cc
@@ -449,9 +449,9 @@ static int read_obj_policy(const DoutPrefixProvider *dpp,
     if (ret < 0) {
       return ret;
     }
-    const rgw_user& bucket_owner = bucket_policy.get_owner().id;
-    if (bucket_owner != s->user->get_id() &&
-        ! s->auth.identity->is_admin_of(bucket_owner)) {
+    const rgw_owner& bucket_owner = bucket_policy.get_owner().id;
+    if (bucket_owner != s->owner.id &&
+        !s->auth.identity->is_admin_of(bucket_owner)) {
       auto r = eval_identity_or_session_policies(dpp, s->iam_user_policies, s->env,
                                   rgw::IAM::s3ListBucket, ARN(bucket->get_key()));
       if (r == Effect::Allow)

diff --git a/src/rgw/rgw_rest.cc b/src/rgw/rgw_rest.cc
index a7c35f3773ccc1b0152d02831e14ad1f346c11e6..3a4abaabd2069cba352bda8e9680589349710199 100644 (file)
--- a/src/rgw/rgw_rest.cc
+++ b/src/rgw/rgw_rest.cc
@@ -498,17 +498,24 @@ void dump_time(req_state *s, const char *name, real_time t)
   s->formatter->dump_string(name, buf);
 }
 
-void dump_owner(req_state *s, const rgw_user& id, const string& name,
+void dump_owner(req_state *s, const std::string& id, const string& name,
                const char *section)
 {
   if (!section)
     section = "Owner";
   s->formatter->open_object_section(section);
-  s->formatter->dump_string("ID", id.to_str());
+  s->formatter->dump_string("ID", id);
   s->formatter->dump_string("DisplayName", name);
   s->formatter->close_section();
 }
 
+void dump_owner(req_state *s, const rgw_owner& owner, const string& name,
+               const char *section)
+{
+  std::string id = to_string(owner);
+  dump_owner(s, id, name, section);
+}
+
 void dump_access_control(req_state *s, const char *origin,
                         const char *meth,
                         const char *hdr, const char *exp_hdr,

diff --git a/src/rgw/rgw_rest.h b/src/rgw/rgw_rest.h
index 8ee587e7c7b473296cec8b6cdf8459eb47873db9..fae60c50f4ddda582055d4b2c12e15babad68eaf 100644 (file)
--- a/src/rgw/rgw_rest.h
+++ b/src/rgw/rgw_rest.h
@@ -705,7 +705,9 @@ extern void end_header(req_state *s,
                       bool force_no_error = false);
 extern void dump_start(req_state *s);
 extern void list_all_buckets_start(req_state *s);
-extern void dump_owner(req_state *s, const rgw_user& id,
+extern void dump_owner(req_state *s, const std::string& id,
+                       const std::string& name, const char *section = NULL);
+extern void dump_owner(req_state *s, const rgw_owner& id,
                        const std::string& name, const char *section = NULL);
 inline void dump_urlsafe(req_state *s, bool encode_key, const char* key, const std::string& val, bool encode_slash = true) {
   if (encode_key) {

diff --git a/src/rgw/rgw_rest_client.cc b/src/rgw/rgw_rest_client.cc
index 164fcf59e8bbc74e56072fd93b337ff6f43ef601..941856e6006d2837d97dbf305e19be9a593c6688 100644 (file)
--- a/src/rgw/rgw_rest_client.cc
+++ b/src/rgw/rgw_rest_client.cc
@@ -506,7 +506,7 @@ static void grants_by_type_add_one_grant(map<int, string>& grants_by_type, int p
     s.append(", ");
 
   if (const auto user = grant.get_user(); user) {
-    s.append("id=\"" + user->id.to_str() + "\"");
+    s.append("id=\"" + to_string(user->id) + "\"");
   } else if (const auto email = grant.get_email(); email) {
     s.append("emailAddress=\"" + email->address + "\"");
   } else if (const auto group = grant.get_group(); group) {

diff --git a/src/rgw/rgw_rest_metadata.cc b/src/rgw/rgw_rest_metadata.cc
index d7881c2289099221c4c305b2dd6e91ad8347ba4d..6630cf053f4f6f034482ba94ca4477e7bde05426 100644 (file)
--- a/src/rgw/rgw_rest_metadata.cc
+++ b/src/rgw/rgw_rest_metadata.cc
@@ -69,8 +69,7 @@ void RGWOp_Metadata_Get::execute(optional_yield y) {
 }
 
 void RGWOp_Metadata_Get_Myself::execute(optional_yield y) {
-  const std::string owner_id = s->owner.id.to_str();
-  s->info.args.append("key", owner_id);
+  s->info.args.append("key", to_string(s->owner.id));
 
   return RGWOp_Metadata_Get::execute(y);
 }

diff --git a/src/rgw/rgw_rest_s3.cc b/src/rgw/rgw_rest_s3.cc
index c2225589216fd3081f40c15a9b6070f5b5e7257e..495651f89d697fc10ae7f0ec808767e9bd562d4a 100644 (file)
--- a/src/rgw/rgw_rest_s3.cc
+++ b/src/rgw/rgw_rest_s3.cc
@@ -1820,7 +1820,7 @@ void RGWListBucket_ObjStore_S3::send_versioned_response()
         auto& storage_class = rgw_placement_rule::get_canonical_storage_class(iter->meta.storage_class);
         s->formatter->dump_string("StorageClass", storage_class.c_str());
       }
-      dump_owner(s, rgw_user(iter->meta.owner), iter->meta.owner_display_name);
+      dump_owner(s, iter->meta.owner, iter->meta.owner_display_name);
       if (iter->meta.appendable) {
         s->formatter->dump_string("Type", "Appendable");
       } else {
@@ -1911,7 +1911,7 @@ void RGWListBucket_ObjStore_S3::send_response()
       s->formatter->dump_int("Size", iter->meta.accounted_size);
       auto& storage_class = rgw_placement_rule::get_canonical_storage_class(iter->meta.storage_class);
       s->formatter->dump_string("StorageClass", storage_class.c_str());
-      dump_owner(s, rgw_user(iter->meta.owner), iter->meta.owner_display_name);
+      dump_owner(s, iter->meta.owner, iter->meta.owner_display_name);
       if (s->system_request) {
        s->formatter->dump_string("RgwxTag", iter->tag);
       }
@@ -1988,7 +1988,7 @@ void RGWListBucket_ObjStore_S3v2::send_versioned_response()
         s->formatter->dump_string("StorageClass", storage_class.c_str());
       }
       if (fetchOwner == true) {
-        dump_owner(s, rgw_user(iter->meta.owner), iter->meta.owner_display_name);
+        dump_owner(s, iter->meta.owner, iter->meta.owner_display_name);
       }
       s->formatter->close_section();
     }
@@ -2056,7 +2056,7 @@ void RGWListBucket_ObjStore_S3v2::send_response()
       auto& storage_class = rgw_placement_rule::get_canonical_storage_class(iter->meta.storage_class);
       s->formatter->dump_string("StorageClass", storage_class.c_str());
       if (fetchOwner == true) {
-        dump_owner(s, rgw_user(iter->meta.owner), iter->meta.owner_display_name);
+        dump_owner(s, iter->meta.owner, iter->meta.owner_display_name);
       }
       if (s->system_request) {
         s->formatter->dump_string("RgwxTag", iter->tag);