acl.encode(aclbl);
attrs[RGW_ATTR_ACL] = aclbl;
- info.owner = acl.get_owner().get_id();
+ info.owner = acl.get_owner().id;
return write_attrs(dpp, y);
}
return -EIO;
}
- int r = static_cast<rgw::sal::RadosStore*>(driver)->ctl()->bucket->unlink_bucket(owner.get_id(), old_bucket->get_info().bucket, y, dpp, false);
+ int r = static_cast<rgw::sal::RadosStore*>(driver)->ctl()->bucket->unlink_bucket(owner.id, old_bucket->get_info().bucket, y, dpp, false);
if (r < 0) {
- set_err_msg(err, "could not unlink policy from user " + owner.get_id().to_str());
+ set_err_msg(err, "could not unlink policy from user " + owner.id.to_str());
return r;
}
std::unique_ptr<rgw::sal::Object::DeleteOp> del_op = obj->get_delete_op();
- del_op->params.bucket_owner = bucket->get_info().owner;
+ del_op->params.bucket_owner.id = bucket->get_info().owner;
del_op->params.obj_owner = policy.get_owner();
if (del_if_older) {
del_op->params.unmod_since = timestamp;
}
del_op->params.olh_epoch = versioned_epoch;
del_op->params.marker_version_id = marker_version_id;
- del_op->params.obj_owner.set_id(rgw_user(owner));
- del_op->params.obj_owner.set_name(owner_display_name);
+ del_op->params.obj_owner.id = rgw_user(owner);
+ del_op->params.obj_owner.display_name = owner_display_name;
del_op->params.mtime = timestamp;
del_op->params.high_precision_time = true;
del_op->params.zones_trace = &zones_trace;
}
ACLOwner new_owner;
- new_owner.set_id(*override_owner);
- new_owner.set_name(owner_info.display_name);
+ new_owner.id = *override_owner;
+ new_owner.display_name = owner_info.display_name;
acl.set_owner(new_owner);
return r;
}
- info.owner = owner.get_id();
+ info.owner = owner.id;
r = put_bucket_instance_info(info, false, real_time(), &attrs, dpp, y);
if (r < 0) {
struct rgw_bucket_dir_entry_meta meta;
- meta.owner = params.obj_owner.get_id().to_str();
- meta.owner_display_name = params.obj_owner.get_display_name();
+ meta.owner = params.obj_owner.id.to_str();
+ meta.owner_display_name = params.obj_owner.display_name;
if (real_clock::is_zero(params.mtime)) {
meta.mtime = real_clock::now();
ldpp_dout(dpp, 0) << "WARNING: could not decode policy ret=" << ret << dendl;
}
}
- ent.meta.owner = owner.get_id().to_str();
- ent.meta.owner_display_name = owner.get_display_name();
+ ent.meta.owner = owner.id.to_str();
+ ent.meta.owner_display_name = owner.display_name;
ent.meta.content_type = content_type;
ent.meta.appendable = appendable;
object.meta.etag = etag;
object.meta.content_type = content_type;
object.meta.storage_class = storage_class;
- object.meta.owner = owner.get_id().to_str();
- object.meta.owner_display_name = owner.get_display_name();
+ object.meta.owner = owner.id.to_str();
+ object.meta.owner_display_name = owner.display_name;
object.meta.appendable = appendable;
// encode suggested updates
list_state.tag = astate->obj_tag.c_str();
}
- list_state.meta.owner = owner.get_id().to_str();
- list_state.meta.owner_display_name = owner.get_display_name();
+ list_state.meta.owner = owner.id.to_str();
+ list_state.meta.owner_display_name = owner.display_name;
list_state.exists = true;
map<string, bufferlist>& attrs = get_attrs();
attrs[RGW_ATTR_ACL] = aclbl;
- info.owner = acl.get_owner().get_id();
+ info.owner = acl.get_owner().id;
int r = store->ctl()->bucket->store_bucket_instance_info(info.bucket,
info, y, dpp,
if (!results.objs.empty()) {
for (const rgw_bucket_dir_entry& dentry : results.objs) {
rgw_obj_key key(dentry.key);
- ACLOwner owner(rgw_user(dentry.meta.owner));
- owner.set_name(dentry.meta.owner_display_name);
+ const ACLOwner owner{
+ .id = rgw_user(dentry.meta.owner),
+ .display_name = dentry.meta.owner_display_name
+ };
uploads.push_back(this->get_multipart_upload(key.name,
std::nullopt, std::move(owner), dentry.meta.mtime));
}
RGWAccessControlList& acl = policy.get_acl();
//Remove grant that is set to old owner
- acl.remove_canon_user_grant(owner.get_id());
+ acl.remove_canon_user_grant(owner.id);
//Create a grant and add grant
ACLGrant grant;
acl.add_grant(&grant);
//Update the ACL owner to the new user
- owner.set_id(new_user.get_id());
- owner.set_name(new_user.get_display_name());
+ owner.id = new_user.get_id();
+ owner.display_name = new_user.get_display_name();
policy.set_owner(owner);
bl.clear();
int RadosObject::RadosDeleteOp::delete_obj(const DoutPrefixProvider* dpp, optional_yield y)
{
- parent_op.params.bucket_owner = params.bucket_owner.get_id();
+ parent_op.params.bucket_owner = params.bucket_owner.id;
parent_op.params.versioning_status = params.versioning_status;
parent_op.params.obj_owner = params.obj_owner;
parent_op.params.olh_epoch = params.olh_epoch;
}
std::unique_ptr<rgw::sal::Object::DeleteOp> del_op = meta_obj->get_delete_op();
- del_op->params.bucket_owner = bucket->get_info().owner;
+ del_op->params.bucket_owner.id = bucket->get_info().owner;
del_op->params.versioning_status = 0;
if (!remove_objs.empty()) {
del_op->params.remove_objs = &remove_objs;
RGWRados::Object::Write obj_op(&op_target);
op_target.set_versioning_disabled(true); /* no versioning for multipart meta */
- obj_op.meta.owner = owner.get_id();
+ obj_op.meta.owner = owner.id;
obj_op.meta.category = RGWObjCategory::MultiMeta;
obj_op.meta.flags = PUT_OBJ_CREATE_EXCL;
obj_op.meta.mtime = &mtime;
obj_op.meta.remove_objs = &remove_objs;
obj_op.meta.ptag = &tag; /* use req_id as operation tag */
- obj_op.meta.owner = owner.get_id();
+ obj_op.meta.owner = owner.id;
obj_op.meta.flags = PUT_OBJ_CREATE;
obj_op.meta.modify_tail = true;
obj_op.meta.completeMultipart = true;
const RGWAccessControlList& acl = policy.get_acl();
- permissions.insert(policy.get_owner().get_id().to_str());
+ permissions.insert(policy.get_owner().id.to_str());
for (auto acliter : acl.get_grant_map()) {
const ACLGrant& grant = acliter.second;
if (grant.get_type().get_type() == ACL_TYPE_CANON_USER &&
s->formatter->dump_format("ETag", "\"%s\"", e.meta.etag.c_str());
s->formatter->dump_string("ContentType", e.meta.content_type.c_str());
s->formatter->dump_string("StorageClass", e.meta.storage_class.c_str());
- dump_owner(s, e.owner.get_id(), e.owner.get_display_name());
+ dump_owner(s, e.owner.id, e.owner.display_name);
s->formatter->open_array_section("CustomMetadata");
for (auto& m : e.meta.custom_str) {
s->formatter->open_object_section("Entry");
string req_id = driver->zone_unique_id(driver->get_new_req_id());
std::unique_ptr<rgw::sal::Writer> processor;
- processor = driver->get_atomic_writer(dpp, y, obj.get(),
- owner.get_id(),
+ processor = driver->get_atomic_writer(dpp, y, obj.get(), owner.id,
nullptr, olh_epoch, req_id);
int ret = processor->prepare(y);
return !(lhs == rhs);
}
-bool operator==(const ACLOwner& lhs, const ACLOwner& rhs) {
- return lhs.id == rhs.id && lhs.display_name == rhs.display_name;
-}
-bool operator!=(const ACLOwner& lhs, const ACLOwner& rhs) {
- return !(lhs == rhs);
-}
-
bool operator==(const RGWAccessControlPolicy& lhs,
const RGWAccessControlPolicy& rhs) {
return lhs.acl == rhs.acl && lhs.owner == rhs.owner;
uint32_t perm = acl.get_perm(dpp, auth_identity, perm_mask);
- if (auth_identity.is_owner_of(owner.get_id())) {
+ if (auth_identity.is_owner_of(owner.id)) {
perm |= perm_mask & (RGW_PERM_READ_ACP | RGW_PERM_WRITE_ACP);
}
}
ldpp_dout(dpp, 5) << "-- Getting permissions done for identity=" << auth_identity
- << ", owner=" << owner.get_id()
+ << ", owner=" << owner.id
<< ", perm=" << perm << dendl;
return perm;
RGWAccessControlList *l = *iter;
p->acl = *l;
- string name = "radosgw";
- rgw_user id("rgw");
- p->owner.set_name(name);
- p->owner.set_id(id);
+ p->owner.id.id = "rgw";
+ p->owner.display_name = "radosgw";
o.push_back(p);
};
WRITE_CLASS_ENCODER(RGWAccessControlList)
-class ACLOwner
-{
-protected:
+struct ACLOwner {
rgw_user id;
std::string display_name;
-public:
- ACLOwner() {}
- ACLOwner(const rgw_user& _id) : id(_id) {}
- ~ACLOwner() {}
void encode(bufferlist& bl) const {
ENCODE_START(3, 2, bl);
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
static void generate_test_instances(std::list<ACLOwner*>& o);
- void set_id(const rgw_user& _id) { id = _id; }
- void set_name(const std::string& name) { display_name = name; }
-
- rgw_user& get_id() { return id; }
- const rgw_user& get_id() const { return id; }
- std::string& get_display_name() { return display_name; }
- const std::string& get_display_name() const { return display_name; }
- friend bool operator==(const ACLOwner& lhs, const ACLOwner& rhs);
- friend bool operator!=(const ACLOwner& lhs, const ACLOwner& rhs);
+
+ auto operator<=>(const ACLOwner&) const = default;
};
WRITE_CLASS_ENCODER(ACLOwner)
DECODE_FINISH(bl);
}
- void set_owner(ACLOwner& o) { owner = o; }
- ACLOwner& get_owner() {
- return owner;
- }
+ 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, std::string& name) {
+ void create_default(const rgw_user& id, const std::string& name) {
acl.create_default(id, name);
- owner.set_id(id);
- owner.set_name(name);
+ owner.id = id;
+ owner.display_name = name;
}
RGWAccessControlList& get_acl() {
return acl;
ACLGrant owner_grant;
- rgw_user bid = bucket_owner.get_id();
- string bname = bucket_owner.get_display_name();
+ const rgw_user& bid = bucket_owner.id;
+ const std::string& bname = bucket_owner.display_name;
/* owner gets full control */
- owner_grant.set_canon(owner.get_id(), owner.get_display_name(), RGW_PERM_FULL_CONTROL);
+ owner_grant.set_canon(owner.id, owner.display_name, RGW_PERM_FULL_CONTROL);
add_grant(&owner_grant);
if (canned_acl.size() == 0 || canned_acl.compare("private") == 0) {
add_grant(&group_grant);
} else if (canned_acl.compare("bucket-owner-read") == 0) {
bucket_owner_grant.set_canon(bid, bname, RGW_PERM_READ);
- if (bid != owner.get_id())
+ if (bid != owner.id) {
add_grant(&bucket_owner_grant);
+ }
} else if (canned_acl.compare("bucket-owner-full-control") == 0) {
bucket_owner_grant.set_canon(bid, bname, RGW_PERM_FULL_CONTROL);
- if (bid != owner.get_id())
+ if (bid != owner.id) {
add_grant(&bucket_owner_grant);
+ }
} else {
return -EINVAL;
}
rgw::sal::Driver* driver, ACLOwner *owner,
RGWAccessControlPolicy& dest, std::string &err_msg)
{
- if (!owner)
+ if (!owner || owner->id.empty()) {
return -EINVAL;
+ }
ACLOwner *requested_owner = static_cast<ACLOwner_S3 *>(find_first("Owner"));
- if (requested_owner) {
- rgw_user& requested_id = requested_owner->get_id();
- if (!requested_id.empty() && requested_id != owner->get_id())
- return -EPERM;
+ if (requested_owner && requested_owner->id != owner->id) {
+ return -EPERM;
}
- std::unique_ptr<rgw::sal::User> user = driver->get_user(owner->get_id());
+ std::unique_ptr<rgw::sal::User> user = driver->get_user(owner->id);
if (user->load_user(dpp, null_yield) < 0) {
ldpp_dout(dpp, 10) << "owner info does not exist" << dendl;
err_msg = "Invalid id";
return -EINVAL;
}
ACLOwner& dest_owner = dest.get_owner();
- dest_owner.set_id(owner->get_id());
- dest_owner.set_name(user->get_display_name());
+ dest_owner.id = owner->id;
+ dest_owner.display_name = user->get_display_name();
- ldpp_dout(dpp, 20) << "owner id=" << owner->get_id() << dendl;
- ldpp_dout(dpp, 20) << "dest owner id=" << dest.get_owner().get_id() << dendl;
+ ldpp_dout(dpp, 20) << "owner id=" << owner->id << dendl;
+ ldpp_dout(dpp, 20) << "dest owner id=" << dest.get_owner().id << dendl;
RGWAccessControlList& dst_acl = dest.get_acl();
virtual int create_canned(ACLOwner& _owner, ACLOwner& bucket_owner, const std::string& canned_acl) {
RGWAccessControlList_S3& _acl = static_cast<RGWAccessControlList_S3 &>(acl);
- if (_owner.get_id() == rgw_user("anonymous")) {
+ if (_owner.id == rgw_user("anonymous")) {
owner = bucket_owner;
} else {
owner = _owner;
uint32_t& rw_mask)
{
acl.create_default(id, name);
- owner.set_id(id);
- owner.set_name(name);
+ owner.id = id;
+ owner.display_name = name;
rw_mask = 0;
if (read_list) {
const std::string& acl_str)
{
acl.create_default(id, name);
- owner.set_id(id);
- owner.set_name(name);
+ owner.id = id;
+ owner.display_name = name;
JSONParser parser;
continue;
}
id = SWIFT_GROUP_ALL_USERS;
- } else if (owner.get_id() == id) {
+ } else if (owner.id == id) {
continue;
}
identity_policy_res == Effect::Allow ||
(e == Effect::Pass &&
identity_policy_res == Effect::Pass &&
- s->auth.identity->is_owner_of(s->bucket_owner.get_id()))) {
+ s->auth.identity->is_owner_of(s->bucket_owner.id))) {
return 0;
} else {
return -EACCES;
}
}
processor = get_driver()->get_atomic_writer(this, state->yield, state->object.get(),
- state->bucket_owner.get_id(),
+ state->bucket_owner.id,
&state->dest_placement, 0, state->req_id);
op_ret = processor->prepare(state->yield);
= obj->get_delete_op();
del_op->params.versioning_status
= obj->get_bucket()->get_info().versioning_status();
- del_op->params.obj_owner.set_id(rgw_user {meta.owner});
- del_op->params.obj_owner.set_name(meta.owner_display_name);
- del_op->params.bucket_owner.set_id(bucket_info.owner);
+ del_op->params.obj_owner.id = rgw_user{meta.owner};
+ del_op->params.obj_owner.display_name = meta.owner_display_name;
+ del_op->params.bucket_owner.id = bucket_info.owner;
del_op->params.unmod_since = meta.mtime;
// notification supported only for RADOS driver for now
s->perm_mask = RGW_PERM_FULL_CONTROL;
// populate the owner info
- s->owner.set_id(s->user->get_id());
- s->owner.set_name(s->user->get_display_name());
+ s->owner.id = s->user->get_id();
+ s->owner.display_name = s->user->get_display_name();
return 0;
} /* RGWHandler_Lib::authorize */
bucket_name = s->bucket_name;
if (!bucket_name.empty()) {
- bucket_name = s->bucket_name;
- user = s->bucket_owner.get_id();
+ bucket_name = s->bucket_name;
+ user = s->bucket_owner.id;
if (!rgw::sal::Bucket::empty(s->bucket.get()) &&
s->bucket->get_info().requester_pays) {
payer = s->user->get_id();
}
} else {
- user = s->user->get_id();
+ user = s->user->get_id();
}
bool error = s->err.is_err();
entry.user = s->user->get_id().to_str();
if (s->object_acl)
- entry.object_owner = s->object_acl->get_owner().get_id();
- entry.bucket_owner = s->bucket_owner.get_id();
+ entry.object_owner = s->object_acl->get_owner().id;
+ entry.bucket_owner = s->bucket_owner.id;
uint64_t bytes_sent = ACCOUNTING_IO(s)->get_bytes_sent();
uint64_t bytes_received = ACCOUNTING_IO(s)->get_bytes_received();
const char* index = luaL_checkstring(L, 2);
if (strcasecmp(index, "DisplayName") == 0) {
- pushstring(L, owner->get_display_name());
+ pushstring(L, owner->display_name);
} else if (strcasecmp(index, "User") == 0) {
- create_metatable<UserMetaTable>(L, name, index, false,
- &(owner->get_id()));
+ create_metatable<UserMetaTable>(L, name, index, false, &owner->id);
} else {
return error_unknown_field(L, index, name);
}
if (ret < 0) {
return ret;
}
- const rgw_user& bucket_owner = bucket_policy.get_owner().get_id();
+ 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)) {
auto r = eval_identity_or_session_policies(dpp, s->iam_user_policies, s->env,
s->bucket_acl.get(), s->bucket->get_key(), y);
acct_acl_user = {
s->bucket->get_info().owner,
- s->bucket_acl->get_owner().get_display_name(),
+ s->bucket_acl->get_owner().display_name,
};
s->bucket_owner = s->bucket_acl->get_owner();
driver->get_user(s->bucket->get_info().owner);
rgw::sal::User* user;
- if (s->user->get_id() == s->bucket_owner.get_id()) {
+ if (s->user->get_id() == s->bucket_owner.id) {
user = s->user.get();
} else {
int r = owner_user->load_user(this, s->yield);
}
}
- s->bucket_owner.set_id(s->user->get_id());
- s->bucket_owner.set_name(s->user->get_display_name());
+ s->bucket_owner.id = s->user->get_id();
+ s->bucket_owner.display_name = s->user->get_display_name();
createparams.owner = s->user->get_id();
buffer::list aclbl;
}
/* admin request overrides permission checks */
- if (! s->auth.identity->is_admin_of(cs_acl.get_owner().get_id())) {
+ if (! s->auth.identity->is_admin_of(cs_acl.get_owner().id)) {
if (policy || ! s->iam_user_policies.empty() || !s->session_policies.empty()) {
//add source object tags for permission evaluation
auto [has_s3_existing_tag, has_s3_resource_tag] = rgw_check_policy_condition(this, policy, s->iam_user_policies, s->session_policies);
return;
}
processor = driver->get_append_writer(this, s->yield, s->object.get(),
- s->bucket_owner.get_id(),
+ s->bucket_owner.id,
pdest_placement, s->req_id, position,
&cur_accounted_size);
} else {
}
}
processor = driver->get_atomic_writer(this, s->yield, s->object.get(),
- s->bucket_owner.get_id(),
+ s->bucket_owner.id,
pdest_placement, olh_epoch, s->req_id);
}
std::unique_ptr<rgw::sal::Writer> processor;
processor = driver->get_atomic_writer(this, s->yield, obj.get(),
- s->bucket_owner.get_id(),
+ s->bucket_owner.id,
&s->dest_placement, 0, s->req_id);
op_ret = processor->prepare(s->yield);
if (op_ret < 0) {
}
/* admin request overrides permission checks */
- if (!s->auth.identity->is_admin_of(src_acl.get_owner().get_id())) {
+ if (!s->auth.identity->is_admin_of(src_acl.get_owner().id)) {
if (src_policy || ! s->iam_user_policies.empty() || !s->session_policies.empty()) {
auto [has_s3_existing_tag, has_s3_resource_tag] = rgw_check_policy_condition(this, src_policy, s->iam_user_policies, s->session_policies);
if (has_s3_existing_tag || has_s3_resource_tag)
}
auto dest_iam_policy = get_iam_policy_from_attr(s->cct, s->bucket->get_attrs(), s->bucket->get_tenant());
/* admin request overrides permission checks */
- if (! s->auth.identity->is_admin_of(dest_policy.get_owner().get_id())){
+ if (! s->auth.identity->is_admin_of(dest_policy.get_owner().id)){
if (dest_iam_policy != boost::none || ! s->iam_user_policies.empty() || !s->session_policies.empty()) {
//Add destination bucket tags for authorization
auto [has_s3_existing_tag, has_s3_resource_tag] = rgw_check_policy_condition(this, dest_iam_policy, s->iam_user_policies, s->session_policies);
if (!path.obj_key.empty()) { // object deletion
ACLOwner bucket_owner;
- bucket_owner.set_id(bucket->get_info().owner);
+ bucket_owner.id = bucket->get_info().owner;
std::unique_ptr<rgw::sal::Object> obj = bucket->get_object(path.obj_key);
obj->set_atomic();
std::unique_ptr<rgw::sal::Writer> processor;
processor = driver->get_atomic_writer(this, s->yield, obj.get(),
- bowner.get_id(),
+ bowner.id,
&s->dest_placement, 0, s->req_id);
op_ret = processor->prepare(s->yield);
if (op_ret < 0) {
int RGWConfigBucketMetaSearch::verify_permission(optional_yield y)
{
- if (!s->auth.identity->is_owner_of(s->bucket_owner.get_id())) {
+ if (!s->auth.identity->is_owner_of(s->bucket_owner.id)) {
return -EACCES;
}
int RGWGetBucketMetaSearch::verify_permission(optional_yield y)
{
- if (!s->auth.identity->is_owner_of(s->bucket_owner.get_id())) {
+ if (!s->auth.identity->is_owner_of(s->bucket_owner.id)) {
return -EACCES;
}
int RGWDelBucketMetaSearch::verify_permission(optional_yield y)
{
- if (!s->auth.identity->is_owner_of(s->bucket_owner.get_id())) {
+ if (!s->auth.identity->is_owner_of(s->bucket_owner.id)) {
return -EACCES;
}
}
void RGWOp_Metadata_Get_Myself::execute(optional_yield y) {
- string owner_id;
-
- owner_id = s->owner.get_id().to_str();
+ const std::string owner_id = s->owner.id.to_str();
s->info.args.append("key", owner_id);
return RGWOp_Metadata_Get::execute(y);
const auto bl = bufferlist::static_from_string(policy_text);
try {
return rgw::IAM::Policy(
- s->cct, s->owner.get_id().tenant, bl,
+ s->cct, s->owner.id.tenant, bl,
s->cct->_conf.get_val<bool>("rgw_policy_reject_invalid_principals"));
} catch (rgw::IAM::PolicyParseException& e) {
ldout(s->cct, 1) << "failed to parse policy:' " << policy_text
const rgw_pubsub_topic& topic,
const std::string& zonegroup_name,
const uint64_t op) {
- if (topic.user == s->owner.get_id()) {
+ if (topic.user == s->owner.id) {
return 0;
}
// no policy set.
return ret;
}
- const RGWPubSub ps(driver, s->owner.get_id().tenant);
+ const RGWPubSub ps(driver, s->owner.id.tenant);
rgw_pubsub_topic result;
ret = ps.get_topic(this, topic_name, result, y);
if (ret == -ENOENT) {
return 0;
}
if (ret == 0) {
- if (result.user == s->owner.get_id() ||
+ if (result.user == s->owner.id ||
!s->cct->_conf->mandatory_topic_permissions) {
return 0;
}
return;
}
}
- const RGWPubSub ps(driver, s->owner.get_id().tenant);
+ const RGWPubSub ps(driver, s->owner.id.tenant);
op_ret = ps.create_topic(this, topic_name, dest, topic_arn, opaque_data,
- s->owner.get_id(), policy_text, y);
+ s->owner.id, policy_text, y);
if (op_ret < 0) {
ldpp_dout(this, 1) << "failed to create topic '" << topic_name << "', ret=" << op_ret << dendl;
return;
};
void RGWPSListTopicsOp::execute(optional_yield y) {
- const RGWPubSub ps(driver, s->owner.get_id().tenant);
+ const RGWPubSub ps(driver, s->owner.id.tenant);
op_ret = ps.get_topics(this, result, y);
// if there are no topics it is not considered an error
op_ret = op_ret == -ENOENT ? 0 : op_ret;
if (op_ret < 0) {
return;
}
- const RGWPubSub ps(driver, s->owner.get_id().tenant);
+ const RGWPubSub ps(driver, s->owner.id.tenant);
op_ret = ps.get_topic(this, topic_name, result, y);
if (op_ret < 0) {
ldpp_dout(this, 1) << "failed to get topic '" << topic_name << "', ret=" << op_ret << dendl;
if (op_ret < 0) {
return;
}
- const RGWPubSub ps(driver, s->owner.get_id().tenant);
+ const RGWPubSub ps(driver, s->owner.id.tenant);
op_ret = ps.get_topic(this, topic_name, result, y);
if (op_ret < 0) {
ldpp_dout(this, 1) << "failed to get topic '" << topic_name << "', ret=" << op_ret << dendl;
return ret;
}
rgw_pubsub_topic result;
- const RGWPubSub ps(driver, s->owner.get_id().tenant);
+ const RGWPubSub ps(driver, s->owner.id.tenant);
ret = ps.get_topic(this, topic_name, result, y);
if (ret < 0) {
ldpp_dout(this, 1) << "failed to get topic '" << topic_name
return;
}
}
- const RGWPubSub ps(driver, s->owner.get_id().tenant);
+ const RGWPubSub ps(driver, s->owner.id.tenant);
op_ret = ps.create_topic(this, topic_name, dest, topic_arn, opaque_data,
topic_owner, policy_text, y);
if (op_ret < 0) {
if (op_ret < 0) {
return;
}
- const RGWPubSub ps(driver, s->owner.get_id().tenant);
+ const RGWPubSub ps(driver, s->owner.id.tenant);
rgw_pubsub_topic result;
op_ret = ps.get_topic(this, topic_name, result, y);
if (op_ret == 0) {
return;
}
- const RGWPubSub ps(driver, s->owner.get_id().tenant);
+ const RGWPubSub ps(driver, s->owner.id.tenant);
const RGWPubSub::Bucket b(ps, bucket.get());
if(configurations.list.empty()) {
// ARN is cached to make the "GET" method faster
op_ret = ps.create_topic(this, unique_topic_name, topic_info.dest,
topic_info.arn, topic_info.opaque_data,
- s->owner.get_id(), topic_info.policy_text, y);
+ s->owner.id, topic_info.policy_text, y);
if (op_ret < 0) {
ldpp_dout(this, 1) << "failed to auto-generate unique topic '" << unique_topic_name <<
"', ret=" << op_ret << dendl;
return;
}
- const RGWPubSub ps(driver, s->owner.get_id().tenant);
+ const RGWPubSub ps(driver, s->owner.id.tenant);
const RGWPubSub::Bucket b(ps, bucket.get());
// get all topics on a bucket
return;
}
- const RGWPubSub ps(driver, s->owner.get_id().tenant);
+ const RGWPubSub ps(driver, s->owner.id.tenant);
const RGWPubSub::Bucket b(ps, bucket.get());
// get all topics on a bucket
return -EACCES;
} else {
/* Populate the owner info. */
- s->owner.set_id(s->user->get_id());
- s->owner.set_name(s->user->get_display_name());
+ s->owner.id = s->user->get_id();
+ s->owner.display_name = s->user->get_display_name();
ldpp_dout(this, 20) << "Successful Signature Verification!" << dendl;
}
s->formatter->dump_string("IsTruncated", (truncated ? "true" : "false"));
ACLOwner& owner = policy.get_owner();
- dump_owner(s, owner.get_id(), owner.get_display_name());
+ dump_owner(s, owner.id, owner.display_name);
for (; iter != upload->get_parts().end(); ++iter) {
rgw::sal::MultipartPart* part = iter->second.get();
}
s->formatter->dump_string("UploadId", upload->get_upload_id());
const ACLOwner& owner = upload->get_owner();
- dump_owner(s, owner.get_id(), owner.get_display_name(), "Initiator");
- dump_owner(s, owner.get_id(), owner.get_display_name()); // Owner
+ dump_owner(s, owner.id, owner.display_name, "Initiator");
+ dump_owner(s, owner.id, owner.display_name); // Owner
s->formatter->dump_string("StorageClass", "STANDARD");
dump_time(s, "Initiated", upload->get_mtime());
s->formatter->close_section();
const auto ret = rgw::auth::Strategy::apply(dpp, auth_registry.get_s3_main(), s, y);
if (ret == 0) {
/* Populate the owner info. */
- s->owner.set_id(s->user->get_id());
- s->owner.set_name(s->user->get_display_name());
+ s->owner.id = s->user->get_id();
+ s->owner.display_name = s->user->get_display_name();
}
return ret;
}
Attrs attrs = get_attrs();
attrs[RGW_ATTR_ACL] = aclbl;
- ret = store->getDB()->update_bucket(dpp, "attrs", info, false, &(acl.get_owner().get_id()), &attrs, nullptr, nullptr);
+ ret = store->getDB()->update_bucket(dpp, "attrs", info, false, &acl.get_owner().id, &attrs, nullptr, nullptr);
return ret;
}
int DBObject::DBDeleteOp::delete_obj(const DoutPrefixProvider* dpp, optional_yield y)
{
- parent_op.params.bucket_owner = params.bucket_owner.get_id();
+ parent_op.params.bucket_owner = params.bucket_owner.id;
parent_op.params.versioning_status = params.versioning_status;
parent_op.params.obj_owner = params.obj_owner;
parent_op.params.olh_epoch = params.olh_epoch;
int ret;
std::unique_ptr<rgw::sal::Object::DeleteOp> del_op = meta_obj->get_delete_op();
- del_op->params.bucket_owner = bucket->get_info().owner;
+ del_op->params.bucket_owner.id = bucket->get_info().owner;
del_op->params.versioning_status = 0;
// Since the data objects are associated with meta obj till
DB::Object::Write obj_op(&op_target);
/* Create meta object */
- obj_op.meta.owner = owner.get_id();
+ obj_op.meta.owner = owner.id;
obj_op.meta.category = RGWObjCategory::MultiMeta;
obj_op.meta.flags = PUT_OBJ_CREATE_EXCL;
obj_op.meta.mtime = &mtime;
DB::Object::Write obj_op(&op_target);
ret = obj_op.prepare(dpp);
- obj_op.meta.owner = owner.get_id();
+ obj_op.meta.owner = owner.id;
obj_op.meta.flags = PUT_OBJ_CREATE;
obj_op.meta.category = RGWObjCategory::Main;
obj_op.meta.modify_tail = true;
)";
DEFINE_REQ_STATE;
- ACLOwner owner;
- owner.set_id(rgw_user("jack", "black"));
- owner.set_name("jack black");
+ const ACLOwner owner{
+ .id = rgw_user("jack", "black"),
+ .display_name = "jack black"
+ };
s.user_acl.reset(new RGWAccessControlPolicy(g_cct));
s.user_acl->set_owner(owner);
ACLGrant grant1, grant2, grant3, grant4, grant5, grant6_1, grant6_2;
)";
DEFINE_REQ_STATE;
- s.owner.set_name("user two");
- s.owner.set_id(rgw_user("tenant2", "user2"));
+ s.owner.display_name = "user two";
+ s.owner.id = rgw_user("tenant2", "user2");
s.user_acl.reset(new RGWAccessControlPolicy());
- s.user_acl->get_owner().set_name("user three");
- s.user_acl->get_owner().set_id(rgw_user("tenant3", "user3"));
+ s.user_acl->get_owner().display_name = "user three";
+ s.user_acl->get_owner().id = rgw_user("tenant3", "user3");
s.bucket_acl.reset(new RGWAccessControlPolicy());
- s.bucket_acl->get_owner().set_name("user four");
- s.bucket_acl->get_owner().set_id(rgw_user("tenant4", "user4"));
+ s.bucket_acl->get_owner().display_name = "user four";
+ s.bucket_acl->get_owner().id = rgw_user("tenant4", "user4");
s.object_acl.reset(new RGWAccessControlPolicy());
- s.object_acl->get_owner().set_name("user five");
- s.object_acl->get_owner().set_id(rgw_user("tenant5", "user5"));
+ s.object_acl->get_owner().display_name = "user five";
+ s.object_acl->get_owner().id = rgw_user("tenant5", "user5");
const auto rc = lua::request::execute(nullptr, nullptr, nullptr, &s, nullptr, script);
ASSERT_EQ(rc, 0);
projects / ceph.git / commitdiff