return next->create(dpp, params, y);
}
-int D4NFilterObject::copy_object(User* user,
+int D4NFilterObject::copy_object(const ACLOwner& owner,
req_info* info,
const rgw_zone_id& source_zone,
rgw::sal::Object* dest_object,
ldpp_dout(dpp, 20) << "D4N Filter: Cache copy object operation succeeded." << dendl;
}
- return next->copy_object(user, info, source_zone,
+ return next->copy_object(owner, info, source_zone,
nextObject(dest_object),
nextBucket(dest_bucket),
nextBucket(src_bucket),
std::unique_ptr<Writer> D4NFilterDriver::get_atomic_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag)
virtual std::unique_ptr<Writer> get_atomic_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag) override;
filter(_filter) {}
virtual ~D4NFilterObject() = default;
- virtual int copy_object(User* user,
+ virtual int copy_object(const ACLOwner& owner,
req_info* info, const rgw_zone_id& source_zone,
rgw::sal::Object* dest_object, rgw::sal::Bucket* dest_bucket,
rgw::sal::Bucket* src_bucket,
}
int DaosObject::copy_object(
- User* user, req_info* info, const rgw_zone_id& source_zone,
+ const ACLOwner& owner, req_info* info, const rgw_zone_id& source_zone,
rgw::sal::Object* dest_object, rgw::sal::Bucket* dest_bucket,
rgw::sal::Bucket* src_bucket, const rgw_placement_rule& dest_placement,
ceph::real_time* src_mtime, ceph::real_time* mtime,
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
-int DaosObject::swift_versioning_restore(bool& restored,
+int DaosObject::swift_versioning_restore(const ACLOwner& owner, bool& restored,
const DoutPrefixProvider* dpp) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
-int DaosObject::swift_versioning_copy(const DoutPrefixProvider* dpp,
+int DaosObject::swift_versioning_copy(const ACLOwner& owner, const DoutPrefixProvider* dpp,
optional_yield y) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
std::unique_ptr<Writer> DaosMultipartUpload::get_writer(
const DoutPrefixProvider* dpp, optional_yield y,
- rgw::sal::Object* obj, const rgw_user& owner,
+ rgw::sal::Object* obj, const ACLOwner& owner,
const rgw_placement_rule* ptail_placement_rule, uint64_t part_num,
const std::string& part_num_str) {
ldpp_dout(dpp, 20) << "DaosMultipartUpload::get_writer(): enter part="
std::unique_ptr<Writer> DaosStore::get_append_writer(
const DoutPrefixProvider* dpp, optional_yield y,
- rgw::sal::Object* obj, const rgw_user& owner,
+ rgw::sal::Object* obj, const ACLOwner& owner,
const rgw_placement_rule* ptail_placement_rule,
const std::string& unique_tag, uint64_t position,
uint64_t* cur_accounted_size) {
std::unique_ptr<Writer> DaosStore::get_atomic_writer(
const DoutPrefixProvider* dpp, optional_yield y,
- rgw::sal::Object* obj, const rgw_user& owner,
+ rgw::sal::Object* obj, const ACLOwner& owner,
const rgw_placement_rule* ptail_placement_rule, uint64_t olh_epoch,
const std::string& unique_tag) {
ldpp_dout(dpp, 20) << "get_atomic_writer" << dendl;
virtual int delete_object(const DoutPrefixProvider* dpp, optional_yield y,
uint32_t flags) override;
virtual int copy_object(
- User* user, req_info* info, const rgw_zone_id& source_zone,
+ const ACLOwner& owner, req_info* info, const rgw_zone_id& source_zone,
rgw::sal::Object* dest_object, rgw::sal::Bucket* dest_bucket,
rgw::sal::Bucket* src_bucket, const rgw_placement_rule& dest_placement,
ceph::real_time* src_mtime, ceph::real_time* mtime,
Formatter* f) override;
/* Swift versioning */
- virtual int swift_versioning_restore(bool& restored,
+ virtual int swift_versioning_restore(const ACLOwner& owner, bool& restored,
const DoutPrefixProvider* dpp) override;
- virtual int swift_versioning_copy(const DoutPrefixProvider* dpp,
+ virtual int swift_versioning_copy(const ACLOwner& owner, const DoutPrefixProvider* dpp,
optional_yield y) override;
/* OPs */
class DaosAtomicWriter : public StoreWriter {
protected:
rgw::sal::DaosStore* store;
- const rgw_user& owner;
+ const ACLOwner& owner;
const rgw_placement_rule* ptail_placement_rule;
uint64_t olh_epoch;
const std::string& unique_tag;
DaosMultipartWriter(const DoutPrefixProvider* dpp, optional_yield y,
MultipartUpload* _upload,
rgw::sal::Object* obj,
- DaosStore* _store, const rgw_user& owner,
+ DaosStore* _store, const ACLOwner& owner,
const rgw_placement_rule* ptail_placement_rule,
uint64_t _part_num, const std::string& part_num_str)
: StoreWriter(dpp, y),
rgw::sal::Attrs* attrs = nullptr) override;
virtual std::unique_ptr<Writer> get_writer(
const DoutPrefixProvider* dpp, optional_yield y,
- rgw::sal::Object* obj, const rgw_user& owner,
+ rgw::sal::Object* obj, const ACLOwner& owner,
const rgw_placement_rule* ptail_placement_rule, uint64_t part_num,
const std::string& part_num_str) override;
const std::string& get_bucket_name() { return bucket->get_name(); }
std::vector<std::unique_ptr<RGWOIDCProvider>>& providers) override;
virtual std::unique_ptr<Writer> get_append_writer(
const DoutPrefixProvider* dpp, optional_yield y,
- rgw::sal::Object* obj, const rgw_user& owner,
+ rgw::sal::Object* obj, const ACLOwner& owner,
const rgw_placement_rule* ptail_placement_rule,
const std::string& unique_tag, uint64_t position,
uint64_t* cur_accounted_size) override;
virtual std::unique_ptr<Writer> get_atomic_writer(
const DoutPrefixProvider* dpp, optional_yield y,
- rgw::sal::Object* obj, const rgw_user& owner,
+ rgw::sal::Object* obj, const ACLOwner& owner,
const rgw_placement_rule* ptail_placement_rule, uint64_t olh_epoch,
const std::string& unique_tag) override;
virtual const std::string& get_compression_type(
return del_op.delete_obj(dpp, y, flags);
}
-int MotrObject::copy_object(User* user,
+int MotrObject::copy_object(const ACLOwner& owner,
req_info* info,
const rgw_zone_id& source_zone,
rgw::sal::Object* dest_object,
return 0;
}
-int MotrObject::swift_versioning_restore(bool& restored,
+int MotrObject::swift_versioning_restore(const ACLOwner& owner, bool& restored,
const DoutPrefixProvider* dpp)
{
return 0;
}
-int MotrObject::swift_versioning_copy(const DoutPrefixProvider* dpp,
+int MotrObject::swift_versioning_copy(const ACLOwner& owner, const DoutPrefixProvider* dpp,
optional_yield y)
{
return 0;
optional_yield y,
rgw::sal::Object* obj,
MotrStore* _store,
- const rgw_user& _owner,
+ const ACLOwner& _owner,
const rgw_placement_rule *_ptail_placement_rule,
uint64_t _olh_epoch,
const std::string& _unique_tag) :
const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num,
const std::string& part_num_str)
std::unique_ptr<Writer> MotrStore::get_append_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
const std::string& unique_tag,
uint64_t position,
std::unique_ptr<Writer> MotrStore::get_atomic_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag) {
virtual int delete_object(const DoutPrefixProvider* dpp,
optional_yield y,
uint32_t flags) override;
- virtual int copy_object(User* user,
+ virtual int copy_object(const ACLOwner& owner,
req_info* info, const rgw_zone_id& source_zone,
rgw::sal::Object* dest_object, rgw::sal::Bucket* dest_bucket,
rgw::sal::Bucket* src_bucket,
virtual int dump_obj_layout(const DoutPrefixProvider *dpp, optional_yield y, Formatter* f) override;
/* Swift versioning */
- virtual int swift_versioning_restore(bool& restored,
+ virtual int swift_versioning_restore(const ACLOwner& owner, bool& restored,
const DoutPrefixProvider* dpp) override;
- virtual int swift_versioning_copy(const DoutPrefixProvider* dpp,
+ virtual int swift_versioning_copy(const ACLOwner& owner, const DoutPrefixProvider* dpp,
optional_yield y) override;
/* OPs */
class MotrAtomicWriter : public StoreWriter {
protected:
rgw::sal::MotrStore* store;
- const rgw_user& owner;
+ const ACLOwner& owner;
const rgw_placement_rule *ptail_placement_rule;
uint64_t olh_epoch;
const std::string& unique_tag;
optional_yield y,
rgw::sal::Object* obj,
MotrStore* _store,
- const rgw_user& _owner,
+ const ACLOwner& _owner,
const rgw_placement_rule *_ptail_placement_rule,
uint64_t _olh_epoch,
const std::string& _unique_tag);
optional_yield y, MultipartUpload* upload,
rgw::sal::Object* obj,
MotrStore* _store,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t _part_num, const std::string& part_num_str) :
StoreWriter(dpp, y), store(_store), head_obj(obj),
virtual std::unique_ptr<Writer> get_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num,
const std::string& part_num_str) override;
virtual std::unique_ptr<Writer> get_append_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
const std::string& unique_tag,
uint64_t position,
virtual std::unique_ptr<Writer> get_atomic_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag) override;
std::unique_ptr<Writer> POSIXDriver::get_append_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* _head_obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
const std::string& unique_tag,
uint64_t position,
std::unique_ptr<Writer> POSIXDriver::get_atomic_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* _head_obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag)
return 0;
}
-int POSIXObject::copy_object(User* user,
+int POSIXObject::copy_object(const ACLOwner& owner,
req_info* info,
const rgw_zone_id& source_zone,
rgw::sal::Object* dest_object,
return 0;
}
-int POSIXObject::swift_versioning_restore(bool& restored,
+int POSIXObject::swift_versioning_restore(const ACLOwner& owner, bool& restored,
const DoutPrefixProvider* dpp, optional_yield y)
{
return 0;
}
-int POSIXObject::swift_versioning_copy(const DoutPrefixProvider* dpp,
+int POSIXObject::swift_versioning_copy(const ACLOwner& owner, const DoutPrefixProvider* dpp,
optional_yield y)
{
return 0;
const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* _head_obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num,
const std::string& part_num_str)
virtual std::unique_ptr<Writer> get_append_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* _head_obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
const std::string& unique_tag,
uint64_t position,
virtual std::unique_ptr<Writer> get_atomic_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* _head_obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag) override;
virtual int delete_object(const DoutPrefixProvider* dpp,
optional_yield y,
uint32_t flags) override;
- virtual int copy_object(User* user,
+ virtual int copy_object(const ACLOwner& owner,
req_info* info, const rgw_zone_id& source_zone,
rgw::sal::Object* dest_object, rgw::sal::Bucket* dest_bucket,
rgw::sal::Bucket* src_bucket,
optional_yield y) override;
virtual bool placement_rules_match(rgw_placement_rule& r1, rgw_placement_rule& r2) override;
virtual int dump_obj_layout(const DoutPrefixProvider *dpp, optional_yield y, Formatter* f) override;
- virtual int swift_versioning_restore(bool& restored,
+ virtual int swift_versioning_restore(const ACLOwner& owner, bool& restored,
const DoutPrefixProvider* dpp, optional_yield y) override;
- virtual int swift_versioning_copy(const DoutPrefixProvider* dpp,
+ virtual int swift_versioning_copy(const ACLOwner& owner, const DoutPrefixProvider* dpp,
optional_yield y) override;
virtual std::unique_ptr<ReadOp> get_read_op() override;
virtual std::unique_ptr<DeleteOp> get_delete_op() override;
virtual std::unique_ptr<Writer> get_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* _head_obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num,
const std::string& part_num_str) override;
class POSIXAtomicWriter : public StoreWriter {
private:
POSIXDriver* driver;
- const rgw_user& owner;
+ const ACLOwner& owner;
const rgw_placement_rule *ptail_placement_rule;
uint64_t olh_epoch;
const std::string& unique_tag;
optional_yield y,
rgw::sal::Object* _head_obj,
POSIXDriver* _driver,
- const rgw_user& _owner,
+ const ACLOwner& _owner,
const rgw_placement_rule *_ptail_placement_rule,
uint64_t _olh_epoch,
const std::string& _unique_tag) :
class POSIXMultipartWriter : public StoreWriter {
private:
POSIXDriver* driver;
- const rgw_user& owner;
+ const ACLOwner& owner;
const rgw_placement_rule *ptail_placement_rule;
uint64_t part_num;
std::unique_ptr<Bucket> shadow_bucket;
std::unique_ptr<Bucket> _shadow_bucket,
rgw_obj_key& _key,
POSIXDriver* _driver,
- const rgw_user& _owner,
+ const ACLOwner& _owner,
const rgw_placement_rule *_ptail_placement_rule,
uint64_t _part_num) :
StoreWriter(dpp, y),
obj_op.meta.mtime = mtime;
obj_op.meta.set_mtime = set_mtime;
obj_op.meta.owner = owner;
+ obj_op.meta.bucket_owner = bucket_info.owner;
obj_op.meta.flags = PUT_OBJ_CREATE;
obj_op.meta.olh_epoch = olh_epoch;
obj_op.meta.delete_at = delete_at;
obj_op.meta.set_mtime = set_mtime;
obj_op.meta.mtime = mtime;
obj_op.meta.owner = owner;
+ obj_op.meta.bucket_owner = bucket_info.owner;
obj_op.meta.delete_at = delete_at;
obj_op.meta.zones_trace = zones_trace;
obj_op.meta.modify_tail = true;
obj_op.meta.mtime = mtime;
obj_op.meta.set_mtime = set_mtime;
obj_op.meta.owner = owner;
+ obj_op.meta.bucket_owner = bucket_info.owner;
obj_op.meta.flags = PUT_OBJ_CREATE;
obj_op.meta.delete_at = delete_at;
obj_op.meta.user_data = user_data;
RGWRados* const store;
RGWBucketInfo& bucket_info;
rgw_placement_rule tail_placement_rule;
- rgw_user owner;
+ ACLOwner owner;
RGWObjectCtx& obj_ctx;
rgw_obj head_obj;
ManifestObjectProcessor(Aio *aio, RGWRados* store,
RGWBucketInfo& bucket_info,
const rgw_placement_rule *ptail_placement_rule,
- const rgw_user& owner, RGWObjectCtx& _obj_ctx,
+ const ACLOwner& owner, RGWObjectCtx& _obj_ctx,
const rgw_obj& _head_obj,
const DoutPrefixProvider* dpp,
optional_yield y,
}
}
- void set_owner(const rgw_user& _owner) {
+ void set_owner(const ACLOwner& _owner) {
owner = _owner;
}
AtomicObjectProcessor(Aio *aio, RGWRados* store,
RGWBucketInfo& bucket_info,
const rgw_placement_rule *ptail_placement_rule,
- const rgw_user& owner,
+ const ACLOwner& owner,
RGWObjectCtx& obj_ctx, const rgw_obj& _head_obj,
std::optional<uint64_t> olh_epoch,
const std::string& unique_tag,
MultipartObjectProcessor(Aio *aio, RGWRados* store,
RGWBucketInfo& bucket_info,
const rgw_placement_rule *ptail_placement_rule,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const ACLOwner& owner, RGWObjectCtx& obj_ctx,
const rgw_obj& _head_obj,
const std::string& upload_id, uint64_t part_num,
const std::string& part_num_str,
AppendObjectProcessor(Aio *aio, RGWRados* store,
RGWBucketInfo& bucket_info,
const rgw_placement_rule *ptail_placement_rule,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const ACLOwner& owner, RGWObjectCtx& obj_ctx,
const rgw_obj& _head_obj,
const std::string& unique_tag, uint64_t position,
uint64_t *cur_accounted_size,
}
int RGWRados::swift_versioning_copy(RGWObjectCtx& obj_ctx,
- const rgw_user& user,
+ const ACLOwner& owner,
RGWBucketInfo& bucket_info,
const rgw_obj& obj,
const DoutPrefixProvider *dpp,
jspan_context no_trace{false, false};
r = copy_obj(obj_ctx,
- user,
+ owner,
NULL, /* req_info *info */
no_zone,
dest_obj,
}
int RGWRados::swift_versioning_restore(RGWObjectCtx& obj_ctx,
- const rgw_user& user,
+ const ACLOwner& owner,
RGWBucketInfo& bucket_info,
rgw_obj& obj,
bool& restored,
jspan_context no_trace{false, false};
int ret = copy_obj(obj_ctx,
- user,
+ owner,
nullptr, /* req_info *info */
no_zone,
obj, /* dest obj */
string etag;
string content_type;
- bufferlist acl_bl;
string storage_class;
map<string, bufferlist>::iterator iter;
etag = rgw_bl_str(bl);
} else if (name.compare(RGW_ATTR_CONTENT_TYPE) == 0) {
content_type = rgw_bl_str(bl);
- } else if (name.compare(RGW_ATTR_ACL) == 0) {
- acl_bl = bl;
}
}
if (attrs.find(RGW_ATTR_PG_VER) == attrs.end()) {
tracepoint(rgw_rados, complete_enter, req_id.c_str());
r = index_op->complete(rctx.dpp, poolid, epoch, size, accounted_size,
meta.set_mtime, etag, content_type,
- storage_class, &acl_bl,
+ storage_class, meta.owner,
meta.category, meta.remove_objs, rctx.y,
meta.user_data, meta.appendable, log_op);
tracepoint(rgw_rados, complete_exit, req_id.c_str());
/* update quota cache */
if (meta.completeMultipart){
- store->quota_handler->update_stats(meta.owner, obj.bucket, (orig_exists ? 0 : 1),
+ store->quota_handler->update_stats(meta.bucket_owner, obj.bucket, (orig_exists ? 0 : 1),
0, orig_size);
}
else {
- store->quota_handler->update_stats(meta.owner, obj.bucket, (orig_exists ? 0 : 1),
+ store->quota_handler->update_stats(meta.bucket_owner, obj.bucket, (orig_exists ? 0 : 1),
accounted_size, orig_size);
}
return 0;
attrset.erase(RGW_ATTR_TAIL_TAG);
attrset.erase(RGW_ATTR_STORAGE_CLASS);
- return copy_obj_data(octx, dest_bucket_info, dest_bucket_info.placement_rule,
+ ACLOwner owner;
+ if (auto i = attrset.find(RGW_ATTR_ACL); i != attrset.end()) {
+ (void) decode_policy(dpp, i->second, &owner);
+ }
+
+ return copy_obj_data(octx, owner, dest_bucket_info,
+ dest_bucket_info.placement_rule,
read_op, obj_size - 1, obj, NULL, mtime,
attrset, 0, real_time(), NULL, dpp, y);
}
std::string etag;
std::string content_type;
std::string storage_class;
+ bool found_acl = false;
bufferlist acl_bl;
bool found_olh_info { false };
bufferlist olh_info_bl;
read_attr(attr_set, RGW_ATTR_ETAG, etag);
read_attr(attr_set, RGW_ATTR_CONTENT_TYPE, content_type);
read_attr(attr_set, RGW_ATTR_STORAGE_CLASS, storage_class);
- read_attr(attr_set, RGW_ATTR_ACL, acl_bl);
+ read_attr(attr_set, RGW_ATTR_ACL, acl_bl, &found_acl);
read_attr(attr_set, RGW_ATTR_OLH_INFO, olh_info_bl, &found_olh_info);
read_attr(attr_set, RGW_ATTR_APPEND_PART_NUM, part_num_bl, &appendable);
}
}
+ ACLOwner owner;
+ if (found_acl) {
+ (void) decode_policy(dpp, acl_bl, &owner);
+ }
+
Bucket bkt(this, bucket_info);
RGWRados::Bucket::UpdateIndex update_idx(&bkt, head_obj);
etag,
content_type,
storage_class,
- &acl_bl,
+ owner,
RGWObjCategory::Main, // RGWObjCategory category,
nullptr, // remove_objs list
y,
set_mtime_weight.high_precision = high_precision_time;
int ret;
+ // use an empty owner until we decode RGW_ATTR_ACL
+ ACLOwner owner;
+ RGWAccessControlPolicy policy;
+
rgw::BlockingAioThrottle aio(cct->_conf->rgw_put_obj_min_window_size);
using namespace rgw::putobj;
jspan_context no_trace{false, false};
AtomicObjectProcessor processor(&aio, this, dest_bucket_info, nullptr,
- user_id, obj_ctx, dest_obj, olh_epoch,
+ owner, obj_ctx, dest_obj, olh_epoch,
tag, rctx.dpp, rctx.y, no_trace);
RGWRESTConn *conn;
auto& zone_conn_map = svc.zone->get_zone_conn_map();
}
}
- if (override_owner) {
- processor.set_owner(*override_owner);
-
- auto& obj_attrs = cb.get_attrs();
+ // decode the ACLOwner from RGW_ATTR_ACL for the bucket index
+ if (auto i = cb.get_attrs().find(RGW_ATTR_ACL); i != cb.get_attrs().end()) {
+ ret = decode_policy(rctx.dpp, i->second, &owner);
+ if (ret < 0) {
+ return ret;
+ }
+ }
+ if (override_owner) {
RGWUserInfo owner_info;
if (ctl.user->get_info_by_uid(rctx.dpp, *override_owner, &owner_info, rctx.y) < 0) {
ldpp_dout(rctx.dpp, 10) << "owner info does not exist" << dendl;
return -EINVAL;
}
- RGWAccessControlPolicy acl;
+ owner.id = *override_owner;
+ owner.display_name = owner_info.display_name;
- auto aiter = obj_attrs.find(RGW_ATTR_ACL);
- if (aiter == obj_attrs.end()) {
- ldpp_dout(rctx.dpp, 0) << "WARNING: " << __func__ << "(): object doesn't have ACL attribute, setting default ACLs" << dendl;
- acl.create_default(owner_info.user_id, owner_info.display_name);
- } else {
- auto iter = aiter->second.cbegin();
- try {
- acl.decode(iter);
- } catch (buffer::error& err) {
- ldpp_dout(rctx.dpp, 0) << "ERROR: " << __func__ << "(): could not decode policy, caught buffer::error" << dendl;
- return -EIO;
- }
- }
-
- ACLOwner new_owner;
- new_owner.id = *override_owner;
- new_owner.display_name = owner_info.display_name;
-
- acl.set_owner(new_owner);
+ policy.create_default(owner_info.user_id, owner_info.display_name);
bufferlist bl;
- acl.encode(bl);
- obj_attrs[RGW_ATTR_ACL] = std::move(bl);
+ policy.encode(bl);
+ cb.get_attrs()[RGW_ATTR_ACL] = std::move(bl);
}
+ processor.set_owner(owner);
+
if (source_zone.empty()) { /* need to preserve expiration if copy in the same zonegroup */
cb.get_attrs().erase(RGW_ATTR_DELETE_AT);
} else {
* Returns: 0 on success, -ERR# otherwise.
*/
int RGWRados::copy_obj(RGWObjectCtx& obj_ctx,
- const rgw_user& user_id,
+ const ACLOwner& owner,
req_info *info,
const rgw_zone_id& source_zone,
const rgw_obj& dest_obj,
if (remote_src || !source_zone.empty()) {
rgw_zone_set_entry source_trace_entry{source_zone.id, std::nullopt};
const req_context rctx{dpp, y, nullptr};
- return fetch_remote_obj(obj_ctx, user_id, info, source_zone,
+ return fetch_remote_obj(obj_ctx, owner.id, info, source_zone,
dest_obj, src_obj, dest_bucket_info, &src_bucket_info,
dest_placement, src_mtime, mtime, mod_ptr,
unmod_ptr, high_precision_time,
if (remote_dest) {
/* dest is in a different zonegroup, copy it there */
- return copy_obj_to_remote_dest(dpp, astate, attrs, read_op, user_id, dest_obj, mtime, y);
+ return copy_obj_to_remote_dest(dpp, astate, attrs, read_op, owner.id, dest_obj, mtime, y);
}
uint64_t max_chunk_size;
if (copy_data) { /* refcounting tail wouldn't work here, just copy the data */
attrs.erase(RGW_ATTR_TAIL_TAG);
- return copy_obj_data(obj_ctx, dest_bucket_info, dest_placement, read_op, obj_size - 1, dest_obj,
+ return copy_obj_data(obj_ctx, owner, dest_bucket_info, dest_placement, read_op, obj_size - 1, dest_obj,
mtime, real_time(), attrs, olh_epoch, delete_at, petag, dpp, y);
}
write_op.meta.data = &first_chunk;
write_op.meta.manifest = pmanifest;
write_op.meta.ptag = &tag;
- write_op.meta.owner = dest_bucket_info.owner;
+ write_op.meta.owner = owner;
+ write_op.meta.bucket_owner = dest_bucket_info.owner;
write_op.meta.mtime = mtime;
write_op.meta.flags = PUT_OBJ_CREATE;
write_op.meta.category = category;
int RGWRados::copy_obj_data(RGWObjectCtx& obj_ctx,
+ const ACLOwner& owner,
RGWBucketInfo& dest_bucket_info,
const rgw_placement_rule& dest_placement,
RGWRados::Object::Read& read_op, off_t end,
using namespace rgw::putobj;
jspan_context no_trace{false, false};
AtomicObjectProcessor processor(aio.get(), this, dest_bucket_info,
- &dest_placement, dest_bucket_info.owner,
+ &dest_placement, owner,
obj_ctx, dest_obj, olh_epoch, tag, dpp, y, no_trace);
int ret = processor.prepare(y);
if (ret < 0)
attrs.erase(RGW_ATTR_ID_TAG);
attrs.erase(RGW_ATTR_TAIL_TAG);
+ ACLOwner owner;
+ if (auto i = attrs.find(RGW_ATTR_ACL); i != attrs.end()) {
+ (void) decode_policy(dpp, i->second, &owner);
+ }
+
ret = copy_obj_data(obj_ctx,
+ owner,
bucket_info,
placement_rule,
read_op,
r = rgw_rados_operate(dpp, ioctx, ref.obj.oid, &op, y);
if (state) {
if (r >= 0) {
- bufferlist acl_bl;
+ ACLOwner owner;
if (iter = attrs.find(RGW_ATTR_ACL); iter != attrs.end()) {
- acl_bl = iter->second;
+ (void) decode_policy(dpp, iter->second, &owner);
}
std::string etag;
if (iter = attrs.find(RGW_ATTR_ETAG); iter != attrs.end()) {
uint64_t epoch = ioctx.get_last_version();
int64_t poolid = ioctx.get_id();
r = index_op.complete(dpp, poolid, epoch, state->size, state->accounted_size,
- mtime, etag, content_type, storage_class, &acl_bl,
+ mtime, etag, content_type, storage_class, owner,
RGWObjCategory::Main, nullptr, y);
} else {
int ret = index_op.cancel(dpp, nullptr, y);
uint64_t size, uint64_t accounted_size,
const ceph::real_time& ut, const string& etag,
const string& content_type, const string& storage_class,
- bufferlist *acl_bl,
+ const ACLOwner& owner,
RGWObjCategory category,
list<rgw_obj_index_key> *remove_objs,
optional_yield y,
if (user_data)
ent.meta.user_data = *user_data;
- ACLOwner owner;
- if (acl_bl && acl_bl->length()) {
- int ret = store->decode_policy(dpp, *acl_bl, &owner);
- if (ret < 0) {
- ldpp_dout(dpp, 0) << "WARNING: could not decode policy ret=" << ret << dendl;
- }
- }
ent.meta.owner = owner.id.to_str();
ent.meta.owner_display_name = owner.display_name;
ent.meta.content_type = content_type;
const std::string *ptag;
std::list<rgw_obj_index_key> *remove_objs;
ceph::real_time set_mtime;
- rgw_user owner;
+ rgw_user bucket_owner; // for quota stats update
+ ACLOwner owner; // owner/owner_display_name for bucket index
RGWObjCategory category;
int flags;
const char *if_match;
RGWRados::Object *target;
struct DeleteParams {
- rgw_user bucket_owner;
+ rgw_user bucket_owner; // for quota stats update
int versioning_status; // versioning flags defined in enum RGWBucketFlags
ACLOwner obj_owner; // needed for creation of deletion marker
uint64_t olh_epoch;
uint64_t accounted_size, const ceph::real_time& ut,
const std::string& etag, const std::string& content_type,
const std::string& storage_class,
- bufferlist *acl_bl, RGWObjCategory category,
+ const ACLOwner& owner, RGWObjCategory category,
std::list<rgw_obj_index_key> *remove_objs,
optional_yield y,
const std::string *user_data = nullptr,
bool swift_versioning_enabled(const RGWBucketInfo& bucket_info) const;
int swift_versioning_copy(RGWObjectCtx& obj_ctx, /* in/out */
- const rgw_user& user, /* in */
+ const ACLOwner& owner, /* in */
RGWBucketInfo& bucket_info, /* in */
const rgw_obj& obj, /* in */
const DoutPrefixProvider *dpp, /* in */
optional_yield y); /* in */
int swift_versioning_restore(RGWObjectCtx& obj_ctx, /* in/out */
- const rgw_user& user, /* in */
+ const ACLOwner& owner, /* in */
RGWBucketInfo& bucket_info, /* in */
rgw_obj& obj, /* in/out */
bool& restored, /* out */
* Returns: 0 on success, -ERR# otherwise.
*/
int copy_obj(RGWObjectCtx& obj_ctx,
- const rgw_user& user_id,
+ const ACLOwner& owner,
req_info *info,
const rgw_zone_id& source_zone,
const rgw_obj& dest_obj,
jspan_context& trace);
int copy_obj_data(RGWObjectCtx& obj_ctx,
+ const ACLOwner& owner,
RGWBucketInfo& dest_bucket_info,
const rgw_placement_rule& dest_placement,
RGWRados::Object::Read& read_op, off_t end,
std::unique_ptr<Writer> RadosStore::get_append_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
const std::string& unique_tag,
uint64_t position,
std::unique_ptr<Writer> RadosStore::get_atomic_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag)
return del_op.delete_obj(y, dpp, flags & FLAG_LOG_OP);
}
-int RadosObject::copy_object(User* user,
+int RadosObject::copy_object(const ACLOwner& owner,
req_info* info,
const rgw_zone_id& source_zone,
rgw::sal::Object* dest_object,
optional_yield y)
{
return store->getRados()->copy_obj(*rados_ctx,
- user->get_id(),
+ owner,
info,
source_zone,
dest_object->get_obj(),
return parent_op.iterate(dpp, ofs, end, cb, y);
}
-int RadosObject::swift_versioning_restore(bool& restored,
+int RadosObject::swift_versioning_restore(const ACLOwner& owner, bool& restored,
const DoutPrefixProvider* dpp, optional_yield y)
{
rgw_obj obj = get_obj();
return store->getRados()->swift_versioning_restore(*rados_ctx,
- bucket->get_owner(),
+ owner,
bucket->get_info(),
obj,
restored,
dpp, y);
}
-int RadosObject::swift_versioning_copy(const DoutPrefixProvider* dpp, optional_yield y)
+int RadosObject::swift_versioning_copy(const ACLOwner& owner, const DoutPrefixProvider* dpp, optional_yield y)
{
return store->getRados()->swift_versioning_copy(*rados_ctx,
- bucket->get_info().owner,
+ owner,
bucket->get_info(),
get_obj(),
dpp,
obj->set_in_extra_data(true);
obj->set_hash_source(oid);
- RGWRados::Object op_target(store->getRados(),
- obj->get_bucket()->get_info(),
+
+ const RGWBucketInfo& bucket_info = obj->get_bucket()->get_info();
+
+ RGWRados::Object op_target(store->getRados(), bucket_info,
obj_ctx, obj->get_obj());
RGWRados::Object::Write obj_op(&op_target);
op_target.set_versioning_disabled(true); /* no versioning for multipart meta */
- obj_op.meta.owner = owner.id;
+ obj_op.meta.owner = owner;
+ obj_op.meta.bucket_owner = bucket_info.owner;
obj_op.meta.category = RGWObjCategory::MultiMeta;
obj_op.meta.flags = PUT_OBJ_CREATE_EXCL;
obj_op.meta.mtime = &mtime;
target_obj->set_atomic();
- RGWRados::Object op_target(store->getRados(),
- target_obj->get_bucket()->get_info(),
+ const RGWBucketInfo& bucket_info = target_obj->get_bucket()->get_info();
+ RGWRados::Object op_target(store->getRados(), bucket_info,
dynamic_cast<RadosObject*>(target_obj)->get_ctx(),
target_obj->get_obj());
RGWRados::Object::Write obj_op(&op_target);
obj_op.meta.remove_objs = &remove_objs;
obj_op.meta.ptag = &tag; /* use req_id as operation tag */
- obj_op.meta.owner = owner.id;
+ obj_op.meta.owner = owner;
+ obj_op.meta.bucket_owner = bucket_info.owner;
obj_op.meta.flags = PUT_OBJ_CREATE;
obj_op.meta.modify_tail = true;
obj_op.meta.completeMultipart = true;
const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num,
const std::string& part_num_str)
virtual std::unique_ptr<Writer> get_append_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
const std::string& unique_tag,
uint64_t position,
virtual std::unique_ptr<Writer> get_atomic_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag) override;
}
virtual int delete_object(const DoutPrefixProvider* dpp,
optional_yield y, uint32_t flags) override;
- virtual int copy_object(User* user,
+ virtual int copy_object(const ACLOwner& owner,
req_info* info, const rgw_zone_id& source_zone,
rgw::sal::Object* dest_object, rgw::sal::Bucket* dest_bucket,
rgw::sal::Bucket* src_bucket,
virtual int dump_obj_layout(const DoutPrefixProvider *dpp, optional_yield y, Formatter* f) override;
/* Swift versioning */
- virtual int swift_versioning_restore(bool& restored,
+ virtual int swift_versioning_restore(const ACLOwner& owner, bool& restored,
const DoutPrefixProvider* dpp, optional_yield y) override;
- virtual int swift_versioning_copy(const DoutPrefixProvider* dpp,
+ virtual int swift_versioning_copy(const ACLOwner& owner, const DoutPrefixProvider* dpp,
optional_yield y) override;
/* OPs */
virtual std::unique_ptr<Writer> get_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num,
const std::string& part_num_str) override;
RGWObjectCtx& obj_ctx,
const rgw_obj& obj,
RadosStore* _store, std::unique_ptr<Aio> _aio,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag,
RGWObjectCtx& obj_ctx,
const rgw_obj& obj,
RadosStore* _store, std::unique_ptr<Aio> _aio,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
const std::string& unique_tag,
uint64_t position,
RGWObjectCtx& obj_ctx,
const rgw_obj& obj,
RadosStore* _store, std::unique_ptr<Aio> _aio,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num, const std::string& part_num_str, jspan_context& trace) :
StoreWriter(dpp, y),
std::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.id,
+ processor = driver->get_atomic_writer(dpp, y, obj.get(), owner,
nullptr, olh_epoch, req_id);
int ret = processor->prepare(y);
}
}
processor = get_driver()->get_atomic_writer(this, state->yield, state->object.get(),
- state->bucket_owner.id,
+ state->bucket_owner,
&state->dest_placement, 0, state->req_id);
op_ret = processor->prepare(state->yield);
/* Handle object versioning of Swift API. */
if (! multipart) {
- op_ret = s->object->swift_versioning_copy(this, s->yield);
+ op_ret = s->object->swift_versioning_copy(s->owner, this, s->yield);
if (op_ret < 0) {
return;
}
pdest_placement = &s->dest_placement;
ldpp_dout(this, 20) << "dest_placement for part=" << *pdest_placement << dendl;
processor = upload->get_writer(this, s->yield, s->object.get(),
- s->user->get_id(), pdest_placement,
+ s->owner, pdest_placement,
multipart_part_num, multipart_part_str);
} else if(append) {
if (s->bucket->versioned()) {
return;
}
processor = driver->get_append_writer(this, s->yield, s->object.get(),
- s->bucket_owner.id,
+ s->owner,
pdest_placement, s->req_id, position,
&cur_accounted_size);
} else {
}
}
processor = driver->get_atomic_writer(this, s->yield, s->object.get(),
- s->bucket_owner.id,
+ s->owner,
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.id,
+ s->owner,
&s->dest_placement, 0, s->req_id);
op_ret = processor->prepare(s->yield);
if (op_ret < 0) {
s->object->set_atomic();
bool ver_restored = false;
- op_ret = s->object->swift_versioning_restore(ver_restored, this, y);
+ op_ret = s->object->swift_versioning_restore(s->owner, ver_restored, this, y);
if (op_ret < 0) {
return;
}
/* Handle object versioning of Swift API. In case of copying to remote this
* should fail gently (op_ret == 0) as the dst_obj will not exist here. */
- op_ret = s->object->swift_versioning_copy(this, s->yield);
+ op_ret = s->object->swift_versioning_copy(s->owner, this, s->yield);
if (op_ret < 0) {
return;
}
- op_ret = s->src_object->copy_object(s->user.get(),
+ op_ret = s->src_object->copy_object(s->owner,
&s->info,
source_zone,
s->object.get(),
dest_placement.inherit_from(bucket->get_placement_rule());
std::unique_ptr<rgw::sal::Writer> processor;
- processor = driver->get_atomic_writer(this, s->yield, obj.get(),
- bowner.id,
+ processor = driver->get_atomic_writer(this, s->yield, obj.get(), bowner,
&s->dest_placement, 0, s->req_id);
op_ret = processor->prepare(s->yield);
if (op_ret < 0) {
virtual std::unique_ptr<Writer> get_append_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
const std::string& unique_tag,
uint64_t position,
virtual std::unique_ptr<Writer> get_atomic_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag) = 0;
optional_yield y,
uint32_t flags) = 0;
/** Copy an this object to another object. */
- virtual int copy_object(User* user,
+ virtual int copy_object(const ACLOwner& owner,
req_info* info, const rgw_zone_id& source_zone,
rgw::sal::Object* dest_object, rgw::sal::Bucket* dest_bucket,
rgw::sal::Bucket* src_bucket,
virtual rgw_obj get_obj(void) const = 0;
/** Restore the previous swift version of this object */
- virtual int swift_versioning_restore(bool& restored, /* out */
+ virtual int swift_versioning_restore(const ACLOwner& owner, bool& restored, /* out */
const DoutPrefixProvider* dpp, optional_yield y) = 0;
/** Copy the current version of a swift object to the configured destination bucket*/
- virtual int swift_versioning_copy(const DoutPrefixProvider* dpp,
+ virtual int swift_versioning_copy(const ACLOwner& owner, const DoutPrefixProvider* dpp,
optional_yield y) = 0;
/** Get a new ReadOp for this object */
virtual std::unique_ptr<Writer> get_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num,
const std::string& part_num_str) = 0;
return del_op.delete_obj(dpp);
}
- int DBObject::copy_object(User* user,
+ int DBObject::copy_object(const ACLOwner& owner,
req_info* info,
const rgw_zone_id& source_zone,
rgw::sal::Object* dest_object,
return parent_op.iterate(dpp, ofs, end, cb);
}
- int DBObject::swift_versioning_restore(bool& restored,
+ int DBObject::swift_versioning_restore(const ACLOwner& owner, bool& restored,
const DoutPrefixProvider* dpp, optional_yield y)
{
return 0;
}
- int DBObject::swift_versioning_copy(const DoutPrefixProvider* dpp,
+ int DBObject::swift_versioning_copy(const ACLOwner& owner, const DoutPrefixProvider* dpp,
optional_yield y)
{
return 0;
const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num,
const std::string& part_num_str)
MultipartUpload* upload,
rgw::sal::Object* obj,
DBStore* _driver,
- const rgw_user& _owner,
+ const ACLOwner& _owner,
const rgw_placement_rule *_ptail_placement_rule,
uint64_t _part_num, const std::string& _part_num_str):
StoreWriter(dpp, y),
optional_yield y,
rgw::sal::Object* _obj,
DBStore* _driver,
- const rgw_user& _owner,
+ const ACLOwner& _owner,
const rgw_placement_rule *_ptail_placement_rule,
uint64_t _olh_epoch,
const std::string& _unique_tag) :
std::unique_ptr<Writer> DBStore::get_append_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
const std::string& unique_tag,
uint64_t position,
std::unique_ptr<Writer> DBStore::get_atomic_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag) {
virtual std::unique_ptr<Writer> get_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num,
const std::string& part_num_str) override;
virtual int delete_object(const DoutPrefixProvider* dpp,
optional_yield y,
uint32_t flags) override;
- virtual int copy_object(User* user,
+ virtual int copy_object(const ACLOwner& owner,
req_info* info, const rgw_zone_id& source_zone,
rgw::sal::Object* dest_object, rgw::sal::Bucket* dest_bucket,
rgw::sal::Bucket* src_bucket,
virtual int dump_obj_layout(const DoutPrefixProvider *dpp, optional_yield y, Formatter* f) override;
/* Swift versioning */
- virtual int swift_versioning_restore(bool& restored,
+ virtual int swift_versioning_restore(const ACLOwner& owner, bool& restored,
const DoutPrefixProvider* dpp, optional_yield y) override;
- virtual int swift_versioning_copy(const DoutPrefixProvider* dpp,
+ virtual int swift_versioning_copy(const ACLOwner& owner, const DoutPrefixProvider* dpp,
optional_yield y) override;
/* OPs */
class DBAtomicWriter : public StoreWriter {
protected:
rgw::sal::DBStore* store;
- const rgw_user& owner;
+ const ACLOwner& owner;
const rgw_placement_rule *ptail_placement_rule;
uint64_t olh_epoch;
const std::string& unique_tag;
optional_yield y,
rgw::sal::Object* obj,
DBStore* _store,
- const rgw_user& _owner,
+ const ACLOwner& _owner,
const rgw_placement_rule *_ptail_placement_rule,
uint64_t _olh_epoch,
const std::string& _unique_tag);
class DBMultipartWriter : public StoreWriter {
protected:
rgw::sal::DBStore* store;
- const rgw_user& owner;
+ const ACLOwner& owner;
const rgw_placement_rule *ptail_placement_rule;
uint64_t olh_epoch;
rgw::sal::Object* head_obj;
optional_yield y, MultipartUpload* upload,
rgw::sal::Object* obj,
DBStore* _store,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num, const std::string& part_num_str);
~DBMultipartWriter() = default;
virtual std::unique_ptr<Writer> get_append_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
const std::string& unique_tag,
uint64_t position,
virtual std::unique_ptr<Writer> get_atomic_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag) override;
std::unique_ptr<Writer> FilterDriver::get_append_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
const std::string& unique_tag,
uint64_t position,
std::unique_ptr<Writer> FilterDriver::get_atomic_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag)
return next->delete_object(dpp, y, flags);
}
-int FilterObject::copy_object(User* user,
+int FilterObject::copy_object(const ACLOwner& owner,
req_info* info,
const rgw_zone_id& source_zone,
rgw::sal::Object* dest_object,
const DoutPrefixProvider* dpp,
optional_yield y)
{
- return next->copy_object(user, info, source_zone,
+ return next->copy_object(owner, info, source_zone,
nextObject(dest_object),
nextBucket(dest_bucket),
nextBucket(src_bucket),
next->set_bucket(nextBucket(b));
};
-int FilterObject::swift_versioning_restore(bool& restored,
+int FilterObject::swift_versioning_restore(const ACLOwner& owner, bool& restored,
const DoutPrefixProvider* dpp, optional_yield y)
{
- return next->swift_versioning_restore(restored, dpp, y);
+ return next->swift_versioning_restore(owner, restored, dpp, y);
}
-int FilterObject::swift_versioning_copy(const DoutPrefixProvider* dpp,
+int FilterObject::swift_versioning_copy(const ACLOwner& owner, const DoutPrefixProvider* dpp,
optional_yield y)
{
- return next->swift_versioning_copy(dpp, y);
+ return next->swift_versioning_copy(owner, dpp, y);
}
std::unique_ptr<Object::ReadOp> FilterObject::get_read_op()
const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num,
const std::string& part_num_str)
virtual std::unique_ptr<Writer> get_append_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule
*ptail_placement_rule,
const std::string& unique_tag,
virtual std::unique_ptr<Writer> get_atomic_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag) override;
virtual int delete_object(const DoutPrefixProvider* dpp,
optional_yield y,
uint32_t flags) override;
- virtual int copy_object(User* user,
+ virtual int copy_object(const ACLOwner& owner,
req_info* info, const rgw_zone_id& source_zone,
rgw::sal::Object* dest_object, rgw::sal::Bucket* dest_bucket,
rgw::sal::Bucket* src_bucket,
virtual bool have_instance(void) override { return next->have_instance(); }
virtual void clear_instance() override { return next->clear_instance(); }
- virtual int swift_versioning_restore(bool& restored, /* out */
+ virtual int swift_versioning_restore(const ACLOwner& owner, bool& restored, /* out */
const DoutPrefixProvider* dpp, optional_yield y) override;
- virtual int swift_versioning_copy(const DoutPrefixProvider* dpp,
+ virtual int swift_versioning_copy(const ACLOwner& owner, const DoutPrefixProvider* dpp,
optional_yield y) override;
virtual std::unique_ptr<ReadOp> get_read_op() override;
virtual std::unique_ptr<Writer> get_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
- const rgw_user& owner,
+ const ACLOwner& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num,
const std::string& part_num_str) override;
int putObject(string name) {
string object_name = "test_object_" + name;
unique_ptr<rgw::sal::Object> obj = testBucket->get_object(rgw_obj_key(object_name));
- rgw_user owner;
+ ACLOwner owner;
rgw_placement_rule ptail_placement_rule;
uint64_t olh_epoch = 123;
string unique_tag;
/* Update object */
RGWEnv rgw_env;
+ ACLOwner owner;
req_info info(get_pointer(env->cct), &rgw_env);
rgw_zone_id source_zone;
rgw_placement_rule dest_placement;
string tag;
string etag;
- EXPECT_EQ(testObject_CopyObjectNone->copy_object(testUser.get(),
+ EXPECT_EQ(testObject_CopyObjectNone->copy_object(owner, testUser->get_id(),
&info, source_zone, testObject_CopyObjectNone.get(),
testBucket.get(), testBucket.get(),
dest_placement, &src_mtime, &mtime,
/* Copy to new object */
unique_ptr<rgw::sal::Writer> testWriterCopy = nullptr;
unique_ptr<rgw::sal::Object> obj = testBucket->get_object(rgw_obj_key("test_object_copy"));
- rgw_user owner;
+ ACLOwner owner;
rgw_placement_rule ptail_placement_rule;
uint64_t olh_epoch_copy = 123;
string unique_tag;
unique_ptr<rgw::sal::Object> testObject_copy = testBucket->get_object(rgw_obj_key("test_object_copy"));
- EXPECT_EQ(testObject_CopyObjectReplace->copy_object(testUser.get(),
+ EXPECT_EQ(testObject_CopyObjectReplace->copy_object(owner, testUser->get_id(),
&info, source_zone, testObject_copy.get(),
testBucket.get(), testBucket.get(),
dest_placement, &src_mtime, &mtime,
unique_ptr<rgw::sal::Writer> testWriterCopy = nullptr;
string object_name = "test_object_copy";
unique_ptr<rgw::sal::Object> obj = testBucket->get_object(rgw_obj_key(object_name));
- rgw_user owner;
+ ACLOwner owner;
rgw_placement_rule ptail_placement_rule;
uint64_t olh_epoch_copy = 123;
string unique_tag;
unique_ptr<rgw::sal::Object> testObject_copy = testBucket->get_object(rgw_obj_key("test_object_copy"));
- EXPECT_EQ(testObject_CopyObjectMerge->copy_object(testUser.get(),
+ EXPECT_EQ(testObject_CopyObjectMerge->copy_object(owner, testUser->get_id(),
&info, source_zone, testObject_copy.get(),
testBucket.get(), testBucket.get(),
dest_placement, &src_mtime, &mtime,
/* Update object */
RGWEnv rgw_env;
req_info info(get_pointer(env->cct), &rgw_env);
+ ACLOwner owner;
rgw_zone_id source_zone;
rgw_placement_rule dest_placement;
ceph::real_time src_mtime;
string tag;
string etag;
- EXPECT_EQ(testObject_PrepareCopyObject->copy_object(testUser.get(),
+ EXPECT_EQ(testObject_PrepareCopyObject->copy_object(owner, testUser->get_id(),
&info, source_zone, testObject_PrepareCopyObject.get(),
testBucket.get(), testBucket.get(),
dest_placement, &src_mtime, &mtime,
/* Prepare, process, and complete object write */
unique_ptr<rgw::sal::Object> obj = testBucket->get_object(rgw_obj_key("test_object_DataCheck"));
- rgw_user owner;
+ ACLOwner owner;
rgw_placement_rule ptail_placement_rule;
uint64_t olh_epoch = 123;
string unique_tag;
projects / ceph.git / commitdiff