ldpp_dout(dpp, 20) << "D4N Filter: Cache get object operation failed." << dendl;
} else {
/* Set metadata locally */
- RGWQuotaInfo quota_info;
RGWObjState* astate;
source->get_obj_state(dpp, &astate, y);
source->set_instance(it->second);
} else if (!std::strcmp(it->first.data(), "source_zone_short_id")) {
astate->zone_short_id = static_cast<uint32_t>(std::stoul(it->second));
- } else if (!std::strcmp(it->first.data(), "user_quota.max_size")) {
- quota_info.max_size = std::stoull(it->second);
- } else if (!std::strcmp(it->first.data(), "user_quota.max_objects")) {
- quota_info.max_objects = std::stoull(it->second);
- } else if (!std::strcmp(it->first.data(), "max_buckets")) {
- source->get_bucket()->get_owner()->set_max_buckets(std::stoull(it->second));
}
}
- source->get_bucket()->get_owner()->set_info(quota_info);
source->set_obj_state(*astate);
/* Set attributes locally */
bl.clear();
}
- RGWUserInfo info = obj->get_bucket()->get_owner()->get_info();
- bl.append(std::to_string(info.quota.user_quota.max_size));
- baseAttrs.insert({"user_quota.max_size", bl});
- bl.clear();
-
- bl.append(std::to_string(info.quota.user_quota.max_objects));
- baseAttrs.insert({"user_quota.max_objects", bl});
- bl.clear();
-
- bl.append(std::to_string(obj->get_bucket()->get_owner()->get_max_buckets()));
- baseAttrs.insert({"max_buckets", bl});
- bl.clear();
-
baseAttrs.insert(attrs.begin(), attrs.end());
int setObjReturn = filter->get_d4n_cache()->setObject(obj->get_key().get_oid(), &baseAttrs);
D4NFilterDriver* filter;
public:
- D4NFilterBucket(std::unique_ptr<Bucket> _next, User* _user, D4NFilterDriver* _filter) :
- FilterBucket(std::move(_next), _user),
+ D4NFilterBucket(std::unique_ptr<Bucket> _next, D4NFilterDriver* _filter) :
+ FilterBucket(std::move(_next)),
filter(_filter) {}
virtual ~D4NFilterBucket() = default;
return std::make_unique<POSIXObject>(this, k);
}
-int POSIXDriver::load_bucket(const DoutPrefixProvider* dpp, User* u, const rgw_bucket& b, std::unique_ptr<Bucket>* bucket, optional_yield y)
+int POSIXDriver::load_bucket(const DoutPrefixProvider* dpp, const rgw_bucket& b, std::unique_ptr<Bucket>* bucket, optional_yield y)
{
- *bucket = std::make_unique<POSIXBucket>(this, root_fd, b, u);
+ *bucket = std::make_unique<POSIXBucket>(this, root_fd, b);
return (*bucket)->load_bucket(dpp, y);
}
-std::unique_ptr<Bucket> POSIXDriver::get_bucket(User* u, const RGWBucketInfo& i)
+std::unique_ptr<Bucket> POSIXDriver::get_bucket(const RGWBucketInfo& i)
{
/* Don't need to fetch the bucket info, use the provided one */
- return std::make_unique<POSIXBucket>(this, root_fd, i, u);
+ return std::make_unique<POSIXBucket>(this, root_fd, i);
}
std::string POSIXDriver::zone_unique_trans_id(const uint64_t unique_num)
const CreateParams& params,
optional_yield y)
{
- ceph_assert(owner);
- info.owner = owner->get_id();
+ info.owner = params.owner;
info.bucket.marker = params.marker;
info.bucket.bucket_id = params.bucket_id;
POSIXObject *pobj;
int ret;
- ret = load_bucket(nullptr, nullptr, rgw_bucket(std::string(), bname),
+ ret = load_bucket(nullptr, rgw_bucket(std::string(), bname),
&b, null_yield);
if (ret < 0)
return ret;
mtime = ceph::real_clock::from_time_t(stx.stx_mtime.tv_sec);
info.creation_time = ceph::real_clock::from_time_t(stx.stx_btime.tv_sec);
- if (owner) {
- info.owner = owner->get_id();
- }
-
ret = open(dpp);
if (ret < 0) {
return ret;
return 0;
}
-int POSIXBucket::chown(const DoutPrefixProvider* dpp, User& new_user, optional_yield y)
+int POSIXBucket::chown(const DoutPrefixProvider* dpp, const rgw_user& new_owner, optional_yield y)
{
/* TODO map user to UID/GID, and change it */
return 0;
open(dpp);
- bp = new POSIXBucket(driver, dir_fd, b, owner, ons);
+ bp = new POSIXBucket(driver, dir_fd, b, ons);
ret = bp->load_bucket(dpp, y);
if (ret == -ENOENT && create) {
/* Create it if it doesn't exist */
std::string& user_str, optional_yield y,
std::unique_ptr<User>* user) override;
virtual std::unique_ptr<Object> get_object(const rgw_obj_key& k) override;
- virtual std::unique_ptr<Bucket> get_bucket(User* u, const RGWBucketInfo& i) override;
- virtual int load_bucket(const DoutPrefixProvider* dpp, User* u, const
- rgw_bucket& b, std::unique_ptr<Bucket>* bucket,
- optional_yield y) override;
+ virtual std::unique_ptr<Bucket> get_bucket(const RGWBucketInfo& i) override;
+ virtual int load_bucket(const DoutPrefixProvider* dpp, const rgw_bucket& b,
+ std::unique_ptr<Bucket>* bucket, optional_yield y) override;
virtual std::string zone_unique_trans_id(const uint64_t unique_num) override;
virtual std::unique_ptr<Writer> get_append_writer(const DoutPrefixProvider *dpp,
std::optional<std::string> ns;
public:
- POSIXBucket(POSIXDriver *_dr, int _p_fd, const rgw_bucket& _b, User* _u, std::optional<std::string> _ns = std::nullopt)
- : StoreBucket(_b, _u),
+ POSIXBucket(POSIXDriver *_dr, int _p_fd, const rgw_bucket& _b, std::optional<std::string> _ns = std::nullopt)
+ : StoreBucket(_b),
driver(_dr),
parent_fd(_p_fd),
acls(),
ns(_ns)
{ }
- POSIXBucket(POSIXDriver *_dr, int _p_fd, const RGWBucketInfo& _i, User* _u)
- : StoreBucket(_i, _u),
+ POSIXBucket(POSIXDriver *_dr, int _p_fd, const RGWBucketInfo& _i)
+ : StoreBucket(_i),
driver(_dr),
parent_fd(_p_fd),
acls()
RGWBucketEnt* ent) override;
virtual int check_bucket_shards(const DoutPrefixProvider* dpp,
uint64_t num_objs, optional_yield y) override;
- virtual int chown(const DoutPrefixProvider* dpp, User& new_user, optional_yield y) override;
+ virtual int chown(const DoutPrefixProvider* dpp, const rgw_user& new_owner, optional_yield y) override;
virtual int put_info(const DoutPrefixProvider* dpp, bool exclusive,
ceph::real_time mtime, optional_yield y) override;
virtual int check_empty(const DoutPrefixProvider* dpp, optional_yield y) override;
for (const auto& ent : listing.buckets) {
std::unique_ptr<rgw::sal::Bucket> bucket;
- int r = driver->load_bucket(dpp, &user,
- rgw_bucket(user.get_tenant(), ent.bucket.name),
+ int r = driver->load_bucket(dpp, rgw_bucket(user.get_tenant(), ent.bucket.name),
&bucket, y);
if (r < 0) {
ldpp_dout(dpp, 0) << "could not get bucket info for bucket=" << bucket << dendl;
<< " got " << bucket << std::endl;
if (fix) {
cout << "fixing" << std::endl;
- r = bucket->chown(dpp, user, y);
+ r = bucket->chown(dpp, user.get_id(), y);
if (r < 0) {
cerr << "failed to fix bucket: " << cpp_strerror(-r) << std::endl;
}
bucket_name = bucket_name.substr(pos + 1);
}
- int r = driver->load_bucket(dpp, user.get(), rgw_bucket(tenant, bucket_name),
+ int r = driver->load_bucket(dpp, rgw_bucket(tenant, bucket_name),
&bucket, y);
if (r < 0) {
set_err_msg(err_msg, "failed to fetch bucket info for bucket=" + bucket_name);
int RGWBucket::chown(RGWBucketAdminOpState& op_state, const string& marker,
optional_yield y, const DoutPrefixProvider *dpp, std::string *err_msg)
{
- /* User passed in by rgw_admin is the new user; get the current user and set it in
- * the bucket */
- std::unique_ptr<rgw::sal::User> old_user = driver->get_user(bucket->get_info().owner);
- bucket->set_owner(old_user.get());
-
return rgw_chown_bucket_and_objects(driver, bucket.get(), user.get(), marker, err_msg, dpp, y);
}
bool bypass_gc, bool keep_index_consistent)
{
std::unique_ptr<rgw::sal::Bucket> bucket;
- std::unique_ptr<rgw::sal::User> user = driver->get_user(op_state.get_user_id());
- int ret = driver->load_bucket(dpp, user.get(),
- rgw_bucket(user->get_tenant(),
- op_state.get_bucket_name()),
+ int ret = driver->load_bucket(dpp, rgw_bucket(op_state.get_tenant(),
+ op_state.get_bucket_name()),
&bucket, y);
if (ret < 0)
return ret;
std::unique_ptr<rgw::sal::Bucket> bucket;
map<RGWObjCategory, RGWStorageStats> stats;
- int ret = driver->load_bucket(dpp, nullptr,
- rgw_bucket(tenant_name, bucket_name),
+ int ret = driver->load_bucket(dpp, rgw_bucket(tenant_name, bucket_name),
&bucket, y);
if (ret < 0) {
return ret;
uint64_t num_objects = 0;
std::unique_ptr<rgw::sal::Bucket> bucket;
- ret = driver->load_bucket(dpp, user.get(), ent.bucket, &bucket, y);
+ ret = driver->load_bucket(dpp, ent.bucket, &bucket, y);
if (ret < 0)
continue;
std::unique_ptr<rgw::sal::Bucket> bucket;
rgw_bucket rbucket;
rgw_bucket_parse_bucket_key(driver->ctx(), bucket_instance, &rbucket, nullptr);
- int r = driver->load_bucket(dpp, nullptr, rbucket, &bucket, y);
+ int r = driver->load_bucket(dpp, rbucket, &bucket, y);
if (r < 0){
// this can only happen if someone deletes us right when we're processing
ldpp_dout(dpp, -1) << "Bucket instance is invalid: " << bucket_instance
auto [tenant, bname] = split_tenant(bucket_name);
RGWBucketInfo cur_bucket_info;
std::unique_ptr<rgw::sal::Bucket> cur_bucket;
- int r = driver->load_bucket(dpp, nullptr, rgw_bucket(tenant, bname),
+ int r = driver->load_bucket(dpp, rgw_bucket(tenant, bname),
&cur_bucket, y);
if (r < 0) {
if (r == -ENOENT) {
Formatter *formatter,
rgw::sal::Driver* driver){
for (const auto &binfo: lst) {
- auto bucket = driver->get_bucket(nullptr, binfo);
+ auto bucket = driver->get_bucket(binfo);
int ret = bucket->purge_instance(dpp, y);
if (ret == 0){
auto md_key = "bucket.instance:" + binfo.bucket.get_key();
const DoutPrefixProvider *dpp, optional_yield y)
{
std::unique_ptr<rgw::sal::Bucket> bucket;
- int ret = driver->load_bucket(dpp, nullptr,
- rgw_bucket(tenant_name, bucket_name),
+ int ret = driver->load_bucket(dpp, rgw_bucket(tenant_name, bucket_name),
&bucket, y);
if (ret < 0) {
// TODO: Should we handle the case where the bucket could've been removed between
ldpp_dout(dpp, -1) << "failed to initialize bucket" << dendl;
return ret;
}
- auto bucket = driver->get_bucket(nullptr, admin_bucket.get_bucket_info());
+ auto bucket = driver->get_bucket(admin_bucket.get_bucket_info());
return fix_bucket_obj_expiry(dpp, driver, bucket.get(), flusher, dry_run, y);
}
/* update lifecyle policy */
{
- auto bucket = bihandler->driver->get_bucket(nullptr, bci.info);
+ auto bucket = bihandler->driver->get_bucket(bci.info);
auto lc = bihandler->driver->get_rgwlc();
if (_zones_trace) {
zones_trace = *_zones_trace;
}
- bucket = store->get_bucket(nullptr, _bucket_info);
+ bucket = store->get_bucket(_bucket_info);
obj = bucket->get_object(_key);
}
};
template<>
int RGWGetBucketInfoCR::Request::_send_request(const DoutPrefixProvider *dpp)
{
- return store->load_bucket(dpp, nullptr,
- rgw_bucket(params.tenant, params.bucket_name),
+ return store->load_bucket(dpp, rgw_bucket(params.tenant, params.bucket_name),
&result->bucket, null_yield);
}
event.x_amz_id_2 = res.store->getRados()->host_id; // RGW on which the change was made
// configurationId is filled from notification configuration
event.bucket_name = res.bucket->get_name();
- event.bucket_ownerIdentity = res.bucket->get_owner() ?
- res.bucket->get_owner()->get_id().id : res.bucket->get_info().owner.id;
+ event.bucket_ownerIdentity = res.bucket->get_owner().id;
const auto region = res.store->get_zone()->get_zonegroup().get_api_name();
rgw::ARN bucket_arn(res.bucket->get_key());
bucket_arn.region = region;
RGWBucketInfo bucket_info;
std::unique_ptr<rgw::sal::Bucket> bucket;
- int ret = driver->load_bucket(dpp, nullptr, rgw_bucket(hint.tenant, hint.bucket_name, hint.bucket_id), &bucket, null_yield);
+ int ret = driver->load_bucket(dpp, rgw_bucket(hint.tenant, hint.bucket_name, hint.bucket_id), &bucket, null_yield);
if (-ENOENT == ret) {
ldpp_dout(dpp, 15) << "NOTICE: cannot find bucket = " \
<< hint.bucket_name << ". The object must be already removed" << dendl;
return;
}
- op_ret = driver->load_bucket(s, nullptr, rgw_bucket("", bucket_name),
+ op_ret = driver->load_bucket(s, rgw_bucket("", bucket_name),
&bucket, y);
if (op_ret < 0) {
ldpp_dout(this, 0) << "get_bucket returned ret=" << op_ret << dendl;
}
if (use_http_params) {
std::unique_ptr<rgw::sal::Bucket> bucket;
- op_ret = driver->load_bucket(s, nullptr, rgw_bucket(uid.tenant, bucket_name),
+ op_ret = driver->load_bucket(s, rgw_bucket(uid.tenant, bucket_name),
&bucket, s->yield);
if (op_ret < 0) {
return;
b.name = bn;
b.bucket_id = bucket_instance;
}
- op_ret = driver->load_bucket(s, nullptr, b, &bucket, y);
+ op_ret = driver->load_bucket(s, b, &bucket, y);
if (op_ret < 0) {
ldpp_dout(this, 5) << "could not get bucket info for bucket=" << bucket_name << dendl;
return;
b.name = bn;
b.bucket_id = bucket_instance;
}
- op_ret = driver->load_bucket(s, nullptr, b, &bucket, y);
+ op_ret = driver->load_bucket(s, b, &bucket, y);
if (op_ret < 0) {
ldpp_dout(this, 5) << "could not get bucket info for bucket=" << bucket_name << dendl;
return;
b.name = bn;
b.bucket_id = bucket_instance;
}
- op_ret = driver->load_bucket(s, nullptr, b, &bucket, y);
+ op_ret = driver->load_bucket(s, b, &bucket, y);
if (op_ret < 0) {
ldpp_dout(this, 5) << "could not get bucket info for bucket=" << bucket_name << dendl;
return;
// read the bucket instance info for num_shards
std::unique_ptr<rgw::sal::Bucket> bucket;
- op_ret = driver->load_bucket(s, nullptr, b, &bucket, y);
+ op_ret = driver->load_bucket(s, b, &bucket, y);
if (op_ret < 0) {
ldpp_dout(this, 4) << "failed to read bucket info: " << cpp_strerror(op_ret) << dendl;
return;
if (*pipe.dest.bucket != pinfo->bucket) {
opt_dest_info.emplace();
std::unique_ptr<rgw::sal::Bucket> dest_bucket;
- op_ret = driver->load_bucket(s, nullptr, *pipe.dest.bucket, &dest_bucket, y);
+ op_ret = driver->load_bucket(s, *pipe.dest.bucket, &dest_bucket, y);
if (op_ret < 0) {
ldpp_dout(this, 4) << "failed to read target bucket info (bucket=: " << cpp_strerror(op_ret) << dendl;
return;
const CreateParams& params,
optional_yield y)
{
- ceph_assert(owner);
- const rgw_user& owner_id = owner->get_id();
-
rgw_bucket key = get_key();
key.marker = params.marker;
key.bucket_id = params.bucket_id;
int ret = store->getRados()->create_bucket(
- dpp, y, key, owner_id, params.zonegroup_id,
+ dpp, y, key, params.owner, params.zonegroup_id,
params.placement_rule, params.zone_placement, params.attrs,
params.obj_lock_enabled, params.swift_ver_location,
params.quota, params.creation_time, &bucket_version, info);
* If all is ok then update the user's list of buckets. Otherwise inform
* client about a name conflict.
*/
- if (info.owner != owner_id) {
+ if (info.owner != params.owner) {
return -ERR_BUCKET_EXISTS;
}
ret = 0;
return ret;
}
- ret = link(dpp, owner, y, false);
+ ret = link(dpp, params.owner, y, false);
if (ret && !existed && ret != -EEXIST) {
/* if it exists (or previously existed), don't remove it! */
- ret = unlink(dpp, owner, y);
+ ret = unlink(dpp, params.owner, y);
if (ret < 0) {
ldpp_dout(dpp, 0) << "WARNING: failed to unlink bucket: ret=" << ret
<< dendl;
int RadosBucket::sync_user_stats(const DoutPrefixProvider *dpp, optional_yield y,
RGWBucketEnt* ent)
{
- return store->ctl()->bucket->sync_user_stats(dpp, owner->get_id(), info, y, ent);
+ return store->ctl()->bucket->sync_user_stats(dpp, info.owner, info, y, ent);
}
int RadosBucket::check_bucket_shards(const DoutPrefixProvider* dpp,
return store->getRados()->check_bucket_shards(info, num_objs, dpp, y);
}
-int RadosBucket::link(const DoutPrefixProvider* dpp, User* new_user, optional_yield y, bool update_entrypoint, RGWObjVersionTracker* objv)
+int RadosBucket::link(const DoutPrefixProvider* dpp, const rgw_user& new_user, optional_yield y, bool update_entrypoint, RGWObjVersionTracker* objv)
{
RGWBucketEntryPoint ep;
ep.bucket = info.bucket;
- ep.owner = new_user->get_id();
+ ep.owner = new_user;
ep.creation_time = get_creation_time();
ep.linked = true;
Attrs ep_attrs;
rgw_ep_info ep_data{ep, ep_attrs};
- int r = store->ctl()->bucket->link_bucket(new_user->get_id(), info.bucket,
+ int r = store->ctl()->bucket->link_bucket(new_user, info.bucket,
get_creation_time(), y, dpp, update_entrypoint,
&ep_data);
if (r < 0)
return r;
}
-int RadosBucket::unlink(const DoutPrefixProvider* dpp, User* new_user, optional_yield y, bool update_entrypoint)
+int RadosBucket::unlink(const DoutPrefixProvider* dpp, const rgw_user& owner, optional_yield y, bool update_entrypoint)
{
- return store->ctl()->bucket->unlink_bucket(new_user->get_id(), info.bucket, y, dpp, update_entrypoint);
+ return store->ctl()->bucket->unlink_bucket(owner, info.bucket, y, dpp, update_entrypoint);
}
-int RadosBucket::chown(const DoutPrefixProvider* dpp, User& new_user, optional_yield y)
+int RadosBucket::chown(const DoutPrefixProvider* dpp, const rgw_user& new_owner, optional_yield y)
{
std::string obj_marker;
- int r;
-
- if (!owner) {
- ldpp_dout(dpp, 0) << __func__ << " Cannot chown without an owner " << dendl;
- return -EINVAL;
- }
-
- r = this->unlink(dpp, owner, y);
+ int r = this->unlink(dpp, info.owner, y);
if (r < 0) {
return r;
}
- return this->link(dpp, &new_user, y);
+ return this->link(dpp, new_owner, y);
}
int RadosBucket::put_info(const DoutPrefixProvider* dpp, bool exclusive, ceph::real_time _mtime, optional_yield y)
RGWUsageIter& usage_iter,
map<rgw_user_bucket, rgw_usage_log_entry>& usage)
{
- return store->getRados()->read_usage(dpp, owner->get_id(), get_name(), start_epoch,
+ return store->getRados()->read_usage(dpp, info.owner, get_name(), start_epoch,
end_epoch, max_entries, is_truncated,
usage_iter, usage);
}
int RadosBucket::trim_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch, optional_yield y)
{
- return store->getRados()->trim_usage(dpp, owner->get_id(), get_name(), start_epoch, end_epoch, y);
+ return store->getRados()->trim_usage(dpp, info.owner, get_name(), start_epoch, end_epoch, y);
}
int RadosBucket::remove_objs_from_index(const DoutPrefixProvider *dpp, std::list<rgw_obj_index_key>& objs_to_unlink)
return std::make_unique<RadosObject>(this, k);
}
-std::unique_ptr<Bucket> RadosStore::get_bucket(User* u, const RGWBucketInfo& i)
+std::unique_ptr<Bucket> RadosStore::get_bucket(const RGWBucketInfo& i)
{
/* Don't need to fetch the bucket info, use the provided one */
- return std::make_unique<RadosBucket>(this, i, u);
+ return std::make_unique<RadosBucket>(this, i);
}
-int RadosStore::load_bucket(const DoutPrefixProvider* dpp, User* u, const rgw_bucket& b,
+int RadosStore::load_bucket(const DoutPrefixProvider* dpp, const rgw_bucket& b,
std::unique_ptr<Bucket>* bucket, optional_yield y)
{
- *bucket = std::make_unique<RadosBucket>(this, b, u);
+ *bucket = std::make_unique<RadosBucket>(this, b);
return (*bucket)->load_bucket(dpp, y);
}
{
rgw_obj obj = get_obj();
return store->getRados()->swift_versioning_restore(*rados_ctx,
- bucket->get_owner()->get_id(),
+ bucket->get_owner(),
bucket->get_info(),
obj,
restored,
virtual int get_user_by_email(const DoutPrefixProvider* dpp, const std::string& email, optional_yield y, std::unique_ptr<User>* user) override;
virtual int get_user_by_swift(const DoutPrefixProvider* dpp, const std::string& user_str, optional_yield y, std::unique_ptr<User>* user) override;
virtual std::unique_ptr<Object> get_object(const rgw_obj_key& k) override;
- std::unique_ptr<Bucket> get_bucket(User* u, const RGWBucketInfo& i) override;
- int load_bucket(const DoutPrefixProvider* dpp, User* u, const rgw_bucket& b,
+ std::unique_ptr<Bucket> get_bucket(const RGWBucketInfo& i) override;
+ int load_bucket(const DoutPrefixProvider* dpp, const rgw_bucket& b,
std::unique_ptr<Bucket>* bucket, optional_yield y) override;
virtual bool is_meta_master() override;
virtual Zone* get_zone() { return zone.get(); }
acls() {
}
- RadosBucket(RadosStore *_st, User* _u)
- : StoreBucket(_u),
- store(_st),
- acls() {
- }
-
RadosBucket(RadosStore *_st, const rgw_bucket& _b)
: StoreBucket(_b),
store(_st),
acls() {
}
- RadosBucket(RadosStore *_st, const rgw_bucket& _b, User* _u)
- : StoreBucket(_b, _u),
- store(_st),
- acls() {
- }
-
- RadosBucket(RadosStore *_st, const RGWBucketInfo& _i, User* _u)
- : StoreBucket(_i, _u),
- store(_st),
- acls() {
- }
-
virtual ~RadosBucket();
virtual std::unique_ptr<Object> get_object(const rgw_obj_key& k) override;
virtual int list(const DoutPrefixProvider* dpp, ListParams&, int, ListResults&, optional_yield y) override;
RGWBucketEnt* ent) override;
int check_bucket_shards(const DoutPrefixProvider* dpp, uint64_t num_objs,
optional_yield y) override;
- virtual int chown(const DoutPrefixProvider* dpp, User& new_user, optional_yield y) override;
+ virtual int chown(const DoutPrefixProvider* dpp, const rgw_user& new_owner, optional_yield y) override;
virtual int put_info(const DoutPrefixProvider* dpp, bool exclusive, ceph::real_time mtime, optional_yield y) override;
virtual int check_empty(const DoutPrefixProvider* dpp, optional_yield y) override;
virtual int check_quota(const DoutPrefixProvider *dpp, RGWQuota& quota, uint64_t obj_size, optional_yield y, bool check_size_only = false) override;
optional_yield y, const DoutPrefixProvider *dpp) override;
private:
- int link(const DoutPrefixProvider* dpp, User* new_user, optional_yield y, bool update_entrypoint = true, RGWObjVersionTracker* objv = nullptr);
- int unlink(const DoutPrefixProvider* dpp, User* new_user, optional_yield y, bool update_entrypoint = true);
+ int link(const DoutPrefixProvider* dpp, const rgw_user& new_owner, optional_yield y, bool update_entrypoint = true, RGWObjVersionTracker* objv = nullptr);
+ int unlink(const DoutPrefixProvider* dpp, const rgw_user& owner, optional_yield y, bool update_entrypoint = true);
friend class RadosUser;
};
int RGWDataAccess::Bucket::init(const DoutPrefixProvider *dpp, optional_yield y)
{
std::unique_ptr<rgw::sal::Bucket> bucket;
- int ret = sd->driver->load_bucket(dpp, nullptr, rgw_bucket(tenant, name), &bucket, y);
+ int ret = sd->driver->load_bucket(dpp, rgw_bucket(tenant, name), &bucket, y);
if (ret < 0) {
return ret;
}
rgw::BlockingAioThrottle aio(driver->ctx()->_conf->rgw_put_obj_min_window_size);
- std::unique_ptr<rgw::sal::Bucket> b = driver->get_bucket(nullptr, bucket_info);
+ std::unique_ptr<rgw::sal::Bucket> b = driver->get_bucket(bucket_info);
std::unique_ptr<rgw::sal::Object> obj = b->get_object(key);
auto& owner = bucket->policy.get_owner();
for (const auto& ent : listing.buckets) {
std::unique_ptr<rgw::sal::Bucket> bucket;
- ret = driver->load_bucket(dpp, old_user.get(), ent.bucket, &bucket, y);
+ ret = driver->load_bucket(dpp, ent.bucket, &bucket, y);
if (ret < 0) {
set_err_msg(err_msg, "failed to fetch bucket info for bucket=" + bucket->get_name());
return ret;
for (const auto& ent : listing.buckets) {
std::unique_ptr<rgw::sal::Bucket> bucket;
- ret = driver->load_bucket(dpp, user, ent.bucket, &bucket, y);
+ ret = driver->load_bucket(dpp, ent.bucket, &bucket, y);
if (ret < 0) {
set_err_msg(err_msg, "unable to load bucket " + ent.bucket.name);
return ret;
}
};
-static int init_bucket(rgw::sal::User* user, const rgw_bucket& b,
+static int init_bucket(const rgw_bucket& b,
std::unique_ptr<rgw::sal::Bucket>* bucket)
{
- return driver->load_bucket(dpp(), user, b, bucket, null_yield);
+ return driver->load_bucket(dpp(), b, bucket, null_yield);
}
-static int init_bucket(rgw::sal::User* user,
- const string& tenant_name,
+static int init_bucket(const string& tenant_name,
const string& bucket_name,
const string& bucket_id,
std::unique_ptr<rgw::sal::Bucket>* bucket)
{
rgw_bucket b{tenant_name, bucket_name, bucket_id};
- return init_bucket(user, b, bucket);
+ return init_bucket(b, bucket);
}
static int read_input(const string& infile, bufferlist& bl)
bool have_max_size, bool have_max_objects)
{
std::unique_ptr<rgw::sal::Bucket> bucket;
- int r = driver->load_bucket(dpp(), nullptr,
- rgw_bucket(tenant_name, bucket_name),
+ int r = driver->load_bucket(dpp(), rgw_bucket(tenant_name, bucket_name),
&bucket, null_yield);
if (r < 0) {
cerr << "could not get bucket info for bucket=" << bucket_name << ": " << cpp_strerror(-r) << std::endl;
bool have_max_read_bytes, bool have_max_write_bytes)
{
std::unique_ptr<rgw::sal::Bucket> bucket;
- int r = driver->load_bucket(dpp(), nullptr,
- rgw_bucket(tenant_name, bucket_name),
+ int r = driver->load_bucket(dpp(), rgw_bucket(tenant_name, bucket_name),
&bucket, null_yield);
if (r < 0) {
cerr << "could not get bucket info for bucket=" << bucket_name << ": " << cpp_strerror(-r) << std::endl;
const string& bucket_name, Formatter *formatter)
{
std::unique_ptr<rgw::sal::Bucket> bucket;
- int r = driver->load_bucket(dpp(), nullptr,
- rgw_bucket(tenant_name, bucket_name),
+ int r = driver->load_bucket(dpp(), rgw_bucket(tenant_name, bucket_name),
&bucket, null_yield);
if (r < 0) {
cerr << "could not get bucket info for bucket=" << bucket_name << ": " << cpp_strerror(-r) << std::endl;
f->open_object_section("bucket");
f->dump_string("bucket", bucket_name);
- int ret = init_bucket(nullptr, tenant_name, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant_name, bucket_name, bucket_id, &bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
return ret;
return 0;
}
-static int init_bucket_for_sync(rgw::sal::User* user,
- const string& tenant, const string& bucket_name,
+static int init_bucket_for_sync(const string& tenant, const string& bucket_name,
const string& bucket_id,
std::unique_ptr<rgw::sal::Bucket>* bucket)
{
- int ret = init_bucket(user, tenant, bucket_name, bucket_id, bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
return ret;
}
std::unique_ptr<rgw::sal::Bucket> source_bucket;
- int r = init_bucket(nullptr, *pipe.source.bucket, &source_bucket);
+ int r = init_bucket(*pipe.source.bucket, &source_bucket);
if (r < 0) {
ldpp_dout(dpp, -1) << "failed to read source bucket info: " << cpp_strerror(r) << dendl;
return r;
for (auto& zone_id : zones) {
for (auto& b : buckets) {
std::unique_ptr<rgw::sal::Bucket> hint_bucket;
- int ret = init_bucket(nullptr, b, &hint_bucket);
+ int ret = init_bucket(b, &hint_bucket);
if (ret < 0) {
ldpp_dout(dpp(), 20) << "could not init bucket info for hint bucket=" << b << " ... skipping" << dendl;
continue;
if (eff_bucket) {
std::unique_ptr<rgw::sal::Bucket> bucket;
- int ret = init_bucket(nullptr, *eff_bucket, &bucket);
+ int ret = init_bucket(*eff_bucket, &bucket);
if (ret < 0 && ret != -ENOENT) {
cerr << "ERROR: init_bucket failed: " << cpp_strerror(-ret) << std::endl;
return ret;
return -EINVAL;
}
- int ret = init_bucket(nullptr, tenant, bucket_name, bucket_id, bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
return ret;
return 0;
}
- ret = init_bucket(nullptr, *b, &bucket);
+ ret = init_bucket(*b, &bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
return ret;
bucket_op.marker = marker;
RGWBucketAdminOp::info(driver, bucket_op, stream_flusher, null_yield, dpp());
} else {
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
return -ret;
cerr << "ERROR: bucket not specified" << std::endl;
return EINVAL;
}
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
return -ret;
}
cerr << "ERROR: bucket not specified" << std::endl;
return EINVAL;
}
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
return -ret;
}
if (!bucket_name.empty()) {
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
return -ret;
}
if (!bucket_name.empty()) {
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
return -ret;
}
if (opt_cmd == OPT::OLH_GET) {
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
return -ret;
}
if (opt_cmd == OPT::OLH_READLOG) {
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
return -ret;
cerr << "ERROR: object not specified" << std::endl;
return EINVAL;
}
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
return -ret;
cerr << "ERROR: bucket name not specified" << std::endl;
return EINVAL;
}
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
return -ret;
return EINVAL;
}
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
ldpp_dout(dpp(), 0) << "ERROR: could not init bucket: " << cpp_strerror(-ret) <<
dendl;
cerr << "ERROR: bucket name not specified" << std::endl;
return EINVAL;
}
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
return -ret;
}
std::unique_ptr<rgw::sal::Bucket> cur_bucket;
- ret = init_bucket(user.get(), tenant, bucket_name, string(), &cur_bucket);
+ ret = init_bucket(tenant, bucket_name, string(), &cur_bucket);
if (ret == -ENOENT) {
// no bucket entrypoint
} else if (ret < 0) {
}
if (opt_cmd == OPT::OBJECT_RM) {
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
return -ret;
return EINVAL;
}
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
return -ret;
return EINVAL;
}
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) <<
"." << std::endl;
return EINVAL;
}
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
return -ret;
return EINVAL;
}
- ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
return -ret;
}
bool bucket_initable = true;
- ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
if (yes_i_really_mean_it) {
bucket_initable = false;
} // OPT_RESHARD_CANCEL
if (opt_cmd == OPT::OBJECT_UNLINK) {
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
return -ret;
}
if (opt_cmd == OPT::OBJECT_STAT) {
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
return -ret;
}
RGWLifecycleConfiguration config;
- ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
return -ret;
if (opt_cmd == OPT::LC_PROCESS) {
if ((! bucket_name.empty()) ||
(! bucket_id.empty())) {
- int ret = init_bucket(nullptr, tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret)
<< std::endl;
if (sync_stats) {
if (!bucket_name.empty()) {
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
return -ret;
cerr << "ERROR: bucket not specified" << std::endl;
return EINVAL;
}
- int ret = init_bucket_for_sync(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket_for_sync(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
return -ret;
}
if (opt_sb && opt_sb->bucket_id.empty()) {
string sbid;
std::unique_ptr<rgw::sal::Bucket> sbuck;
- int ret = init_bucket_for_sync(user.get(), opt_sb->tenant, opt_sb->name, sbid, &sbuck);
+ int ret = init_bucket_for_sync(opt_sb->tenant, opt_sb->name, sbid, &sbuck);
if (ret < 0) {
return -ret;
}
cerr << "ERROR: bucket not specified" << std::endl;
return EINVAL;
}
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
return -ret;
}
cerr << "ERROR: bucket not specified" << std::endl;
return EINVAL;
}
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
return -ret;
}
cerr << "ERROR: bucket not specified" << std::endl;
return EINVAL;
}
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
return -ret;
}
cerr << "ERROR: bucket not specified" << std::endl;
return EINVAL;
}
- int ret = init_bucket_for_sync(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket_for_sync(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
return -ret;
}
cerr << "ERROR: bucket not specified" << std::endl;
return EINVAL;
}
- int ret = init_bucket_for_sync(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket_for_sync(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
return -ret;
}
cerr << "ERROR: bucket not specified" << std::endl;
return EINVAL;
}
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
return -ret;
cerr << "ERROR: bucket not specified" << std::endl;
return EINVAL;
}
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
return -ret;
cerr << "ERROR: bucket not specified" << std::endl;
return EINVAL;
}
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
return -ret;
RGWPubSub ps(driver, tenant);
rgw_pubsub_bucket_topics result;
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
return -ret;
return EINVAL;
}
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
return -ret;
return EINVAL;
}
- int ret = init_bucket(user.get(), tenant, bucket_name, bucket_id, &bucket);
+ int ret = init_bucket(tenant, bucket_name, bucket_id, &bucket);
if (ret < 0) {
cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
return -ret;
const DoutPrefixProvider *dpp, optional_yield y)
{
/* Chown on the bucket */
- int ret = bucket->chown(dpp, *new_user, y);
+ int ret = bucket->chown(dpp, new_user->get_id(), y);
if (ret < 0) {
set_err_msg(err_msg, "Failed to change object ownership: " + cpp_strerror(-ret));
}
/* notifications */
auto& bucket = oc.bucket;
- auto& bucket_info = oc.bucket->get_info();
std::string version_id;
- std::unique_ptr<rgw::sal::User> user;
- user = oc.driver->get_user(bucket_info.owner);
- if (! bucket->get_owner()) {
- if (user) {
- bucket->set_owner(user.get());
- }
- }
-
auto& obj = oc.obj;
const auto event_type = (bucket->versioned() &&
return 0;
}
- int ret = driver->load_bucket(this, nullptr,
- rgw_bucket(bucket_tenant, bucket_name),
+ int ret = driver->load_bucket(this, rgw_bucket(bucket_tenant, bucket_name),
&bucket, null_yield);
if (ret < 0) {
ldpp_dout(this, 0) << "LC:get_bucket for " << bucket_name
return ret;
}
- ret = bucket->load_bucket(this, null_yield);
- if (ret < 0) {
- ldpp_dout(this, 0) << "LC:load_bucket for " << bucket_name
- << " failed" << dendl;
- return ret;
- }
-
auto stack_guard = make_scope_guard(
[&worker]
{
worker->workpool->drain();
}
- std::unique_ptr<rgw::sal::User> user;
- if (! bucket->get_owner()) {
- auto& bucket_info = bucket->get_info();
- std::unique_ptr<rgw::sal::User> user = driver->get_user(bucket_info.owner);
- if (user) {
- bucket->set_owner(user.get());
- }
- }
-
ret = handle_multipart_expiration(bucket.get(), prefix_map, worker, stop_at, once);
return ret;
}
create_metatable<PlacementRuleMetaTable>(L, name, index, false, &(bucket->get_info().placement_rule));
} else if (strcasecmp(index, "User") == 0) {
create_metatable<UserMetaTable>(L, name, index, false,
- const_cast<rgw_user*>(&bucket->get_owner()->get_id()));
+ const_cast<rgw_user*>(&bucket->get_owner()));
} else {
return error_unknown_field(L, index, name);
}
/* check if copy source is within the current domain */
if (!s->src_bucket_name.empty()) {
std::unique_ptr<rgw::sal::Bucket> src_bucket;
- ret = driver->load_bucket(dpp, nullptr,
- rgw_bucket(s->src_tenant_name, s->src_bucket_name),
+ ret = driver->load_bucket(dpp, rgw_bucket(s->src_tenant_name,
+ s->src_bucket_name),
&src_bucket, y);
if (ret == 0) {
s->local_source = zonegroup.equals(src_bucket->get_info().zonegroup);
/* This is the only place that s->bucket is created. It should never be
* overwritten. */
- ret = driver->load_bucket(dpp, s->user.get(),
- rgw_bucket(s->bucket_tenant, s->bucket_name,
- s->bucket_instance_id),
+ ret = driver->load_bucket(dpp, rgw_bucket(s->bucket_tenant, s->bucket_name,
+ s->bucket_instance_id),
&s->bucket, y);
if (ret < 0) {
if (ret != -ENOENT) {
if (bucket_name.compare(s->bucket->get_name()) != 0) {
map<string, bufferlist> bucket_attrs;
- r = driver->load_bucket(this, s->user.get(),
- rgw_bucket(s->user->get_tenant(), bucket_name),
+ r = driver->load_bucket(this, rgw_bucket(s->user->get_tenant(), bucket_name),
&ubucket, y);
if (r < 0) {
ldpp_dout(this, 0) << "could not get bucket info for bucket="
RGWAccessControlPolicy& _bucket_acl = allocated_acls.back();
std::unique_ptr<rgw::sal::Bucket> tmp_bucket;
- int r = driver->load_bucket(this, s->user.get(),
- rgw_bucket(s->user->get_tenant(), bucket_name),
+ int r = driver->load_bucket(this, rgw_bucket(s->user->get_tenant(),
+ bucket_name),
&tmp_bucket, y);
if (r < 0) {
ldpp_dout(this, 0) << "could not get bucket info for bucket="
return;
}
- op_ret = driver->load_bucket(this, s->user.get(), s->bucket->get_key(), &bucket, y);
+ op_ret = driver->load_bucket(this, s->bucket->get_key(), &bucket, y);
if (op_ret) {
return;
}
}
// read the bucket info if it exists
- op_ret = driver->load_bucket(this, s->user.get(),
- rgw_bucket(s->bucket_tenant, s->bucket_name),
+ op_ret = driver->load_bucket(this, rgw_bucket(s->bucket_tenant, s->bucket_name),
&s->bucket, y);
if (op_ret < 0 && op_ret != -ENOENT)
return;
s->bucket_owner.set_id(s->user->get_id());
s->bucket_owner.set_name(s->user->get_display_name());
+ createparams.owner = s->user->get_id();
buffer::list aclbl;
policy.encode(aclbl);
op_ret = s->bucket->load_bucket(this, y);
if (op_ret < 0) {
return;
- } else if (!s->bucket->is_owner(s->user.get())) {
+ } else if (s->bucket->get_owner() != s->user->get_id()) {
/* New bucket doesn't belong to the account we're operating on. */
op_ret = -EEXIST;
return;
}
}
std::unique_ptr<rgw::sal::Bucket> bucket;
- ret = driver->load_bucket(this, s->user.get(),
- rgw_bucket(copy_source_tenant_name,
- copy_source_bucket_name),
+ ret = driver->load_bucket(this, rgw_bucket(copy_source_tenant_name,
+ copy_source_bucket_name),
&bucket, y);
if (ret < 0) {
- ldpp_dout(this, 5) << __func__ << "(): get_bucket() returned ret=" << ret << dendl;
+ ldpp_dout(this, 5) << __func__ << "(): load_bucket() returned ret=" << ret << dendl;
if (ret == -ENOENT) {
ret = -ERR_NO_SUCH_BUCKET;
}
return ret;
}
-
- ret = bucket->load_bucket(this, y);
- if (ret < 0) {
- ldpp_dout(this, 5) << __func__ << "(): load_bucket() returned ret=" << ret << dendl;
- return ret;
- }
copy_source_bucket_info = bucket->get_info();
/* handle x-amz-copy-source-range */
RGWAccessControlPolicy cs_acl(s->cct);
boost::optional<Policy> policy;
map<string, bufferlist> cs_attrs;
- auto cs_bucket = driver->get_bucket(nullptr, copy_source_bucket_info);
+ auto cs_bucket = driver->get_bucket(copy_source_bucket_info);
auto cs_object = cs_bucket->get_object(rgw_obj_key(copy_source_object_name,
copy_source_version_id));
cs_object->set_atomic();
new_ofs = fst;
new_end = lst;
- auto bucket = driver->get_bucket(nullptr, copy_source_bucket_info);
+ auto bucket = driver->get_bucket(copy_source_bucket_info);
auto obj = bucket->get_object(rgw_obj_key(copy_source_object_name,
copy_source_version_id));
auto read_op = obj->get_read_op();
return;
}
if ((! copy_source.empty()) && !copy_source_range) {
- auto bucket = driver->get_bucket(nullptr, copy_source_bucket_info);
+ auto bucket = driver->get_bucket(copy_source_bucket_info);
auto obj = bucket->get_object(rgw_obj_key(copy_source_object_name,
copy_source_version_id));
return op_ret;
}
- op_ret = driver->load_bucket(this, s->user.get(),
- rgw_bucket(s->src_tenant_name,
- s->src_bucket_name),
+ op_ret = driver->load_bucket(this, rgw_bucket(s->src_tenant_name,
+ s->src_bucket_name),
&src_bucket, y);
if (op_ret < 0) {
if (op_ret == -ENOENT) {
ACLOwner bowner;
RGWObjVersionTracker ot;
- int ret = driver->load_bucket(dpp, s->user.get(),
- rgw_bucket(s->user->get_tenant(),
- path.bucket_name),
+ int ret = driver->load_bucket(dpp, rgw_bucket(s->user->get_tenant(),
+ path.bucket_name),
&bucket, y);
if (ret < 0) {
goto binfo_fail;
// load the bucket
std::unique_ptr<rgw::sal::Bucket> bucket;
- ret = driver->load_bucket(this, s->user.get(), new_bucket, &bucket, y);
+ ret = driver->load_bucket(this, new_bucket, &bucket, y);
// return success if it exists
if (ret != -ENOENT) {
const auto& zonegroup = s->penv.site->get_zonegroup();
rgw::sal::Bucket::CreateParams createparams;
+ createparams.owner = s->user->get_id();
createparams.zonegroup_id = zonegroup.id;
createparams.placement_rule.storage_class = s->info.storage_class;
op_ret = select_bucket_placement(this, zonegroup, s->user->get_info(),
std::unique_ptr<rgw::sal::Bucket> bucket;
ACLOwner bowner;
- op_ret = driver->load_bucket(this, s->user.get(),
- rgw_bucket(s->user->get_tenant(), bucket_name),
+ op_ret = driver->load_bucket(this, rgw_bucket(s->user->get_tenant(),
+ bucket_name),
&bucket, y);
if (op_ret < 0) {
if (op_ret == -ENOENT) {
}
std::unique_ptr<rgw::sal::Bucket> cur_bucket;
- ret = store->load_bucket(dpp, nullptr, orphan_bucket, &cur_bucket, null_yield);
+ ret = store->load_bucket(dpp, orphan_bucket, &cur_bucket, null_yield);
if (ret < 0) {
if (ret == -ENOENT) {
/* probably raced with bucket removal */
rgw_bucket b;
rgw_bucket_parse_bucket_key(store->ctx(), bucket_instance_id, &b, nullptr);
std::unique_ptr<rgw::sal::Bucket> bucket;
- ret = store->load_bucket(dpp, nullptr, b, &bucket, null_yield);
+ ret = store->load_bucket(dpp, b, &bucket, null_yield);
if (ret < 0) {
if (ret == -ENOENT) {
/* probably raced with bucket removal */
continue;
}
- auto bucket = store->get_bucket(nullptr, bucket_info);
+ auto bucket = store->get_bucket(bucket_info);
// we need to do this in two cases below, so use a lambda
auto do_stat_key =
[&](const rgw_obj_key& key) -> int {
bucket_process_map.erase(front);
std::unique_ptr<rgw::sal::Bucket> bucket;
- ret = store->load_bucket(dpp, nullptr, rgw_bucket(tenant_name, bucket_name),
+ ret = store->load_bucket(dpp, rgw_bucket(tenant_name, bucket_name),
&bucket, null_yield);
if (ret == -ENOENT) {
std::cerr << "WARNING: bucket " << bucket_name <<
// initial bucket
std::unique_ptr<rgw::sal::Bucket> bucket;
- ret = store->load_bucket(dpp, nullptr,
- rgw_bucket(tenant_name, start_bucket_name),
+ ret = store->load_bucket(dpp, rgw_bucket(tenant_name, start_bucket_name),
&bucket, null_yield);
if (ret == -ENOENT) {
// bucket deletion race?
std::unique_ptr<rgw::sal::Bucket> rbucket;
const DoutPrefix dp(driver->ctx(), dout_subsys, "rgw bucket async refresh handler: ");
- int r = driver->load_bucket(&dp, nullptr, bucket, &rbucket, null_yield);
+ int r = driver->load_bucket(&dp, bucket, &rbucket, null_yield);
if (r < 0) {
ldpp_dout(&dp, 0) << "could not get bucket info for bucket=" << bucket << " r=" << r << dendl;
return r;
std::unique_ptr<rgw::sal::User> user = driver->get_user(_u);
std::unique_ptr<rgw::sal::Bucket> bucket;
- int r = driver->load_bucket(dpp, user.get(), _b, &bucket, y);
+ int r = driver->load_bucket(dpp, _b, &bucket, y);
if (r < 0) {
ldpp_dout(dpp, 0) << "could not get bucket info for bucket=" << _b << " r=" << r << dendl;
return r;
std::unique_ptr<rgw::sal::User> user = driver->get_user(_u);
std::unique_ptr<rgw::sal::Bucket> bucket;
- int r = driver->load_bucket(dpp, user.get(), _b, &bucket, y);
+ int r = driver->load_bucket(dpp, _b, &bucket, y);
if (r < 0) {
ldpp_dout(dpp, 0) << "could not get bucket info for bucket=" << _b << " r=" << r << dendl;
return r;
return;
}
- std::unique_ptr<rgw::sal::User> user = driver->get_user(s->owner.get_id());
std::unique_ptr<rgw::sal::Bucket> bucket;
- op_ret = driver->load_bucket(this, user.get(),
- rgw_bucket(s->bucket_tenant, s->bucket_name),
+ op_ret = driver->load_bucket(this, rgw_bucket(s->bucket_tenant, s->bucket_name),
&bucket, y);
if (op_ret < 0) {
ldpp_dout(this, 1) << "failed to get bucket '" <<
return;
}
- std::unique_ptr<rgw::sal::User> user = driver->get_user(s->owner.get_id());
std::unique_ptr<rgw::sal::Bucket> bucket;
- op_ret = driver->load_bucket(this, user.get(),
- rgw_bucket(s->bucket_tenant, s->bucket_name),
+ op_ret = driver->load_bucket(this, rgw_bucket(s->bucket_tenant, s->bucket_name),
&bucket, y);
if (op_ret < 0) {
ldpp_dout(this, 1) << "failed to get bucket '" <<
return;
}
- std::unique_ptr<rgw::sal::User> user = driver->get_user(s->owner.get_id());
std::unique_ptr<rgw::sal::Bucket> bucket;
- op_ret = driver->load_bucket(this, user.get(),
- rgw_bucket(s->bucket_tenant, s->bucket_name),
+ op_ret = driver->load_bucket(this, rgw_bucket(s->bucket_tenant, s->bucket_name),
&bucket, y);
if (op_ret < 0) {
ldpp_dout(this, 1) << "failed to get bucket '" <<
if (ratelimit_scope == "bucket" && !bucket_name.empty() && !global) {
std::unique_ptr<rgw::sal::Bucket> bucket;
- int r = driver->load_bucket(s, nullptr,
- rgw_bucket(tenant_name, bucket_name),
+ int r = driver->load_bucket(s, rgw_bucket(tenant_name, bucket_name),
&bucket, y);
if (r != 0) {
op_ret = r;
if (ratelimit_scope == "bucket" && !bucket_name.empty() && !global) {
ldpp_dout(this, 0) << "getting bucket info" << dendl;
std::unique_ptr<rgw::sal::Bucket> bucket;
- op_ret = driver->load_bucket(this, nullptr,
- rgw_bucket(tenant_name, bucket_name),
+ op_ret = driver->load_bucket(this, rgw_bucket(tenant_name, bucket_name),
&bucket, y);
if (op_ret) {
ldpp_dout(this, 0) << "Error on getting bucket info" << dendl;
dump_header(s, "X-RGW-Bytes-Used", static_cast<long long>(stats.size));
// only bucket's owner is allowed to get the quota settings of the account
- if (bucket->is_owner(s->user.get())) {
+ if (bucket->get_owner() == s->user->get_id()) {
auto user_info = s->user->get_info();
auto bucket_quota = s->bucket->get_info().quota; // bucket quota
dump_header(s, "X-RGW-Quota-User-Size", static_cast<long long>(user_info.quota.user_quota.max_size));
std::unique_ptr<rgw::sal::Bucket> bucket;
if (bucket_name.compare(s->bucket->get_name()) != 0) {
- r = driver->load_bucket(s, s->user.get(),
- rgw_bucket(s->user->get_id().tenant, bucket_name),
+ r = driver->load_bucket(s, rgw_bucket(s->user->get_tenant(), bucket_name),
&bucket, s->yield);
if (r < 0) {
ldpp_dout(this, 0) << "could not get bucket info for bucket="
/* Need to get user info of bucket owner. */
std::unique_ptr<rgw::sal::Bucket> bucket;
- int ret = driver->load_bucket(s, user.get(),
- rgw_bucket(bucket_tenant, bucket_name),
+ int ret = driver->load_bucket(s, rgw_bucket(bucket_tenant, bucket_name),
&bucket, s->yield);
if (ret < 0) {
throw ret;
string uid_str;
string bucket_name;
+ string tenant;
uint64_t start, end;
bool show_entries;
bool show_summary;
RESTArgs::get_string(s, "uid", uid_str, &uid_str);
RESTArgs::get_string(s, "bucket", bucket_name, &bucket_name);
+ RESTArgs::get_string(s, "tenant", "", &tenant);
std::unique_ptr<rgw::sal::User> user = driver->get_user(rgw_user(uid_str));
std::unique_ptr<rgw::sal::Bucket> bucket;
if (!bucket_name.empty()) {
- op_ret = driver->load_bucket(nullptr, user.get(),
- rgw_bucket(std::string(), bucket_name),
+ op_ret = driver->load_bucket(this, rgw_bucket(tenant, bucket_name),
&bucket, null_yield);
if (op_ret < 0) {
return;
void RGWOp_Usage_Delete::execute(optional_yield y) {
string uid_str;
string bucket_name;
+ string tenant;
uint64_t start, end;
RESTArgs::get_string(s, "uid", uid_str, &uid_str);
RESTArgs::get_string(s, "bucket", bucket_name, &bucket_name);
+ RESTArgs::get_string(s, "tenant", "", &tenant);
std::unique_ptr<rgw::sal::User> user = driver->get_user(rgw_user(uid_str));
std::unique_ptr<rgw::sal::Bucket> bucket;
if (!bucket_name.empty()) {
- op_ret = driver->load_bucket(nullptr, user.get(),
- rgw_bucket(std::string(), bucket_name),
+ op_ret = driver->load_bucket(this, rgw_bucket(tenant, bucket_name),
&bucket, null_yield);
if (op_ret < 0) {
return;
* there is a Bucket, otherwise use the get_object() in the Bucket class. */
virtual std::unique_ptr<Object> get_object(const rgw_obj_key& k) = 0;
/** Get a Bucket by info. Does not query the driver, just uses the give bucket info. */
- virtual std::unique_ptr<Bucket> get_bucket(User* u, const RGWBucketInfo& i) = 0;
+ virtual std::unique_ptr<Bucket> get_bucket(const RGWBucketInfo& i) = 0;
/** Load a Bucket by key. Queries driver for bucket info. On -ENOENT, the
* bucket must still be allocated to support bucket->create(). */
- virtual int load_bucket(const DoutPrefixProvider* dpp, User* u, const rgw_bucket& b,
+ virtual int load_bucket(const DoutPrefixProvider* dpp, const rgw_bucket& b,
std::unique_ptr<Bucket>* bucket, optional_yield y) = 0;
/** For multisite, this driver is the zone's master */
virtual bool is_meta_master() = 0;
/** Set the ACL for this bucket */
virtual int set_acl(const DoutPrefixProvider* dpp, RGWAccessControlPolicy& acl, optional_yield y) = 0;
- // XXXX hack
- virtual void set_owner(rgw::sal::User* _owner) = 0;
-
/// Input parameters for create().
struct CreateParams {
+ rgw_user owner;
std::string zonegroup_id;
rgw_placement_rule placement_rule;
// zone placement is optional on buckets created for another zonegroup
uint64_t num_objs, optional_yield y) = 0;
/** Change the owner of this bucket in the backing store. Current owner must be set. Does not
* change ownership of the objects in the bucket. */
- virtual int chown(const DoutPrefixProvider* dpp, User& new_user, optional_yield y) = 0;
+ virtual int chown(const DoutPrefixProvider* dpp, const rgw_user& new_owner, optional_yield y) = 0;
/** Store the cached bucket info into the backing store */
virtual int put_info(const DoutPrefixProvider* dpp, bool exclusive, ceph::real_time mtime, optional_yield y) = 0;
- /** Check to see if the given user is the owner of this bucket */
- virtual bool is_owner(User* user) = 0;
/** Get the owner of this bucket */
- virtual User* get_owner(void) = 0;
+ virtual const rgw_user& get_owner() const = 0;
/** Check in the backing store if this bucket is empty */
virtual int check_empty(const DoutPrefixProvider* dpp, optional_yield y) = 0;
/** Chec k if the given size fits within the quota */
const CreateParams& params,
optional_yield y)
{
- ceph_assert(owner);
- const rgw_user& owner_id = owner->get_id();
-
rgw_bucket key = get_key();
key.marker = params.marker;
key.bucket_id = params.bucket_id;
/* XXX: We may not need to send all these params. Cleanup the unused ones */
- return store->getDB()->create_bucket(dpp, owner_id, key,
+ return store->getDB()->create_bucket(dpp, params.owner, key,
params.zonegroup_id, params.placement_rule, params.attrs,
params.swift_ver_location, params.quota, params.creation_time,
&bucket_version, info, y);
return 0;
}
- int DBBucket::chown(const DoutPrefixProvider *dpp, User& new_user, optional_yield y)
+ int DBBucket::chown(const DoutPrefixProvider *dpp, const rgw_user& new_owner, optional_yield y)
{
int ret;
- ret = store->getDB()->update_bucket(dpp, "owner", info, false, &(new_user.get_id()), nullptr, nullptr, nullptr);
+ ret = store->getDB()->update_bucket(dpp, "owner", info, false, &new_owner, nullptr, nullptr, nullptr);
return ret;
}
}
- std::unique_ptr<Bucket> DBStore::get_bucket(User* u, const RGWBucketInfo& i)
+ std::unique_ptr<Bucket> DBStore::get_bucket(const RGWBucketInfo& i)
{
/* Don't need to fetch the bucket info, use the provided one */
- return std::make_unique<DBBucket>(this, i, u);
+ return std::make_unique<DBBucket>(this, i);
}
- int DBStore::load_bucket(const DoutPrefixProvider *dpp, User* u, const rgw_bucket& b,
+ int DBStore::load_bucket(const DoutPrefixProvider *dpp, const rgw_bucket& b,
std::unique_ptr<Bucket>* bucket, optional_yield y)
{
- *bucket = std::make_unique<DBBucket>(this, b, u);
+ *bucket = std::make_unique<DBBucket>(this, b);
return (*bucket)->load_bucket(dpp, y);
}
acls() {
}
- DBBucket(DBStore *_st, User* _u)
- : StoreBucket(_u),
- store(_st),
- acls() {
- }
-
DBBucket(DBStore *_st, const rgw_bucket& _b)
: StoreBucket(_b),
store(_st),
acls() {
}
- DBBucket(DBStore *_st, const rgw_bucket& _b, User* _u)
- : StoreBucket(_b, _u),
- store(_st),
- acls() {
- }
-
- DBBucket(DBStore *_st, const RGWBucketInfo& _i, User* _u)
- : StoreBucket(_i, _u),
- store(_st),
- acls() {
- }
-
~DBBucket() { }
virtual std::unique_ptr<Object> get_object(const rgw_obj_key& k) override;
RGWBucketEnt* ent) override;
int check_bucket_shards(const DoutPrefixProvider *dpp,
uint64_t num_objs, optional_yield y) override;
- virtual int chown(const DoutPrefixProvider *dpp, User& new_user, optional_yield y) override;
+ virtual int chown(const DoutPrefixProvider *dpp, const rgw_user& new_owner, optional_yield y) override;
virtual int put_info(const DoutPrefixProvider *dpp, bool exclusive, ceph::real_time mtime, optional_yield y) override;
virtual int check_empty(const DoutPrefixProvider *dpp, optional_yield y) override;
virtual int check_quota(const DoutPrefixProvider *dpp, RGWQuota& quota, uint64_t obj_size, optional_yield y, bool check_size_only = false) override;
virtual int get_user_by_swift(const DoutPrefixProvider *dpp, const std::string& user_str, optional_yield y, std::unique_ptr<User>* user) override;
virtual std::unique_ptr<Object> get_object(const rgw_obj_key& k) override;
virtual std::string get_cluster_id(const DoutPrefixProvider* dpp, optional_yield y);
- std::unique_ptr<Bucket> get_bucket(User* u, const RGWBucketInfo& i) override;
- int load_bucket(const DoutPrefixProvider *dpp, User* u, const rgw_bucket& b,
+ std::unique_ptr<Bucket> get_bucket(const RGWBucketInfo& i) override;
+ int load_bucket(const DoutPrefixProvider *dpp, const rgw_bucket& b,
std::unique_ptr<Bucket>* bucket, optional_yield y) override;
virtual bool is_meta_master() override;
virtual Zone* get_zone() { return &zone; }
return std::make_unique<FilterObject>(std::move(o));
}
-std::unique_ptr<Bucket> FilterDriver::get_bucket(User* u, const RGWBucketInfo& i)
+std::unique_ptr<Bucket> FilterDriver::get_bucket(const RGWBucketInfo& i)
{
- return std::make_unique<FilterBucket>(next->get_bucket(nextUser(u), i), u);
+ return std::make_unique<FilterBucket>(next->get_bucket(i));
}
-int FilterDriver::load_bucket(const DoutPrefixProvider* dpp, User* u, const rgw_bucket& b, std::unique_ptr<Bucket>* bucket, optional_yield y)
+int FilterDriver::load_bucket(const DoutPrefixProvider* dpp, const rgw_bucket& b,
+ std::unique_ptr<Bucket>* bucket, optional_yield y)
{
std::unique_ptr<Bucket> nb;
- const int ret = next->load_bucket(dpp, nextUser(u), b, &nb, y);
- *bucket = std::make_unique<FilterBucket>(std::move(nb), u);
+ const int ret = next->load_bucket(dpp, b, &nb, y);
+ *bucket = std::make_unique<FilterBucket>(std::move(nb));
return ret;
}
return next->check_bucket_shards(dpp, num_objs, y);
}
-int FilterBucket::chown(const DoutPrefixProvider* dpp, User& new_user, optional_yield y)
+int FilterBucket::chown(const DoutPrefixProvider* dpp, const rgw_user& new_owner, optional_yield y)
{
- return next->chown(dpp, new_user, y);
+ return next->chown(dpp, new_owner, y);
}
int FilterBucket::put_info(const DoutPrefixProvider* dpp, bool exclusive,
return next->put_info(dpp, exclusive, _mtime, y);
}
-bool FilterBucket::is_owner(User* user)
+const rgw_user& FilterBucket::get_owner() const
{
- return next->is_owner(nextUser(user));
+ return next->get_owner();
}
int FilterBucket::check_empty(const DoutPrefixProvider* dpp, optional_yield y)
std::string& user_str, optional_yield y,
std::unique_ptr<User>* user) override;
virtual std::unique_ptr<Object> get_object(const rgw_obj_key& k) override;
- std::unique_ptr<Bucket> get_bucket(User* u, const RGWBucketInfo& i) override;
- int load_bucket(const DoutPrefixProvider* dpp, User* u,
- const rgw_bucket& b, std::unique_ptr<Bucket>* bucket,
- optional_yield y) override;
+ std::unique_ptr<Bucket> get_bucket(const RGWBucketInfo& i) override;
+ int load_bucket(const DoutPrefixProvider* dpp, const rgw_bucket& b,
+ std::unique_ptr<Bucket>* bucket, optional_yield y) override;
virtual bool is_meta_master() override;
virtual Zone* get_zone() override { return zone.get(); }
virtual std::string zone_unique_id(uint64_t unique_num) override;
class FilterBucket : public Bucket {
protected:
std::unique_ptr<Bucket> next;
-private:
- User* user;
public:
- FilterBucket(std::unique_ptr<Bucket> _next, User* _user) :
- next(std::move(_next)), user(_user) {}
+ FilterBucket(std::unique_ptr<Bucket> _next) : next(std::move(_next)) {}
virtual ~FilterBucket() = default;
virtual std::unique_ptr<Object> get_object(const rgw_obj_key& key) override;
virtual int set_acl(const DoutPrefixProvider* dpp, RGWAccessControlPolicy& acl,
optional_yield y) override;
- virtual void set_owner(rgw::sal::User* _owner) override { next->set_owner(_owner); }
virtual int create(const DoutPrefixProvider* dpp,
const CreateParams& params,
optional_yield y) override;
RGWBucketEnt* ent) override;
int check_bucket_shards(const DoutPrefixProvider* dpp,
uint64_t num_objs, optional_yield y) override;
- virtual int chown(const DoutPrefixProvider* dpp, User& new_user,
+ virtual int chown(const DoutPrefixProvider* dpp, const rgw_user& new_owner,
optional_yield y) override;
virtual int put_info(const DoutPrefixProvider* dpp, bool exclusive,
ceph::real_time mtime, optional_yield y) override;
- virtual bool is_owner(User* user) override;
- virtual User* get_owner(void) override { return user; }
+ virtual const rgw_user& get_owner() const override;
virtual int check_empty(const DoutPrefixProvider* dpp, optional_yield y) override;
virtual int check_quota(const DoutPrefixProvider *dpp, RGWQuota& quota,
uint64_t obj_size, optional_yield y,
virtual bool versioning_enabled() override { return next->versioning_enabled(); }
virtual std::unique_ptr<Bucket> clone() override {
- std::unique_ptr<Bucket> nb = next->clone();
- return std::make_unique<FilterBucket>(std::move(nb), user);
+ return std::make_unique<FilterBucket>(next->clone());
}
virtual std::unique_ptr<MultipartUpload> get_multipart_upload(
class StoreBucket : public Bucket {
protected:
RGWBucketInfo info;
- User* owner = nullptr;
Attrs attrs;
obj_version bucket_version;
ceph::real_time mtime;
public:
StoreBucket() = default;
- StoreBucket(User* u) : owner(u) { }
StoreBucket(const rgw_bucket& b) { info.bucket = b; }
StoreBucket(const RGWBucketInfo& i) : info(i) {}
- StoreBucket(const rgw_bucket& b, User* u) : owner(u) { info.bucket = b; }
- StoreBucket(const RGWBucketInfo& i, User* u) : info(i), owner(u) {}
virtual ~StoreBucket() = default;
virtual Attrs& get_attrs(void) override { return attrs; }
virtual int set_attrs(Attrs a) override { attrs = a; return 0; }
- virtual void set_owner(rgw::sal::User* _owner) override {
- owner = _owner;
- info.owner = owner->get_id();
- }
- virtual User* get_owner(void) override { return owner; };
- /* Make sure to call get_bucket_info() if you need it first */
- virtual bool is_owner(User* user) override { return (info.owner.compare(user->get_id()) == 0); }
+ virtual const rgw_user& get_owner() const override { return info.owner; };
virtual bool empty() const override { return info.bucket.name.empty(); }
virtual const std::string& get_name() const override { return info.bucket.name; }
virtual const std::string& get_tenant() const override { return info.bucket.tenant; }
b.tenant = std::move(bucket_tenant);
b.name = std::move(bucket_name);
std::unique_ptr<rgw::sal::Bucket> bucket;
- int ret = driver->load_bucket(dpp, nullptr, b, &bucket, s->yield);
+ int ret = driver->load_bucket(dpp, b, &bucket, s->yield);
if (ret < 0) {
throw ret;
}
for (auto& ent : listing.buckets) {
std::unique_ptr<rgw::sal::Bucket> bucket;
- ret = driver->load_bucket(dpp, user, ent.bucket, &bucket, y);
+ ret = driver->load_bucket(dpp, ent.bucket, &bucket, y);
if (ret < 0) {
ldpp_dout(dpp, 0) << "ERROR: could not read bucket info: bucket=" << bucket << " ret=" << ret << dendl;
continue;
RGWBucketInfo info;
info.bucket.name = "test_bucket";
- testBucket = driver->get_bucket(testUser.get(), info);
+ testBucket = driver->get_bucket(info);
rgw::sal::Bucket::CreateParams params;
params.zonegroup_id = "test_id";
value.push_back(make_pair("source_zone_short_id", "300"));
value.push_back(make_pair("bucket_count", "10"));
value.push_back(make_pair("bucket_size", "20"));
- value.push_back(make_pair("user_quota.max_size", "0"));
- value.push_back(make_pair("user_quota.max_objects", "0"));
- value.push_back(make_pair("max_buckets", "2000"));
client.hmset("rgw-object:test_object_StoreGetMetadata:cache", value, [](cpp_redis::reply& reply) {
if (!reply.is_null()) {
ASSERT_EQ(testROp->prepare(null_yield, dpp), 0);
/* Check updated metadata values */
- RGWUserInfo info = testObject_StoreGetMetadata->get_bucket()->get_owner()->get_info();
static StoreObject* storeObject = static_cast<StoreObject*>(dynamic_cast<rgw::sal::FilterObject*>(testObject_StoreGetMetadata.get())->get_next());
EXPECT_EQ(to_iso_8601(storeObject->state.mtime), "2021-11-08T21:13:38.334696731Z");
EXPECT_EQ(storeObject->state.accounted_size, (uint64_t)200);
EXPECT_EQ(storeObject->state.epoch, (uint64_t)3);
EXPECT_EQ(storeObject->state.zone_short_id, (uint32_t)300);
- EXPECT_EQ(info.quota.user_quota.max_size, (int64_t)0);
- EXPECT_EQ(info.quota.user_quota.max_objects, (int64_t)0);
- EXPECT_EQ(testObject_StoreGetMetadata->get_bucket()->get_owner()->get_max_buckets(), (int32_t)2000);
}
TEST_F(D4NFilterFixture, StoreModifyAttr) {
DEFINE_REQ_STATE;
- rgw_bucket b;
- b.tenant = "mytenant";
- b.name = "myname";
- b.marker = "mymarker";
- b.bucket_id = "myid";
- s.bucket.reset(new sal::RadosBucket(nullptr, b));
- s.bucket->set_owner(new sal::RadosUser(nullptr, rgw_user("mytenant", "myuser")));
+ RGWBucketInfo info;
+ info.bucket.tenant = "mytenant";
+ info.bucket.name = "myname";
+ info.bucket.marker = "mymarker";
+ info.bucket.bucket_id = "myid";
+ info.owner.id = "myuser";
+ info.owner.tenant = "mytenant";
+ s.bucket.reset(new sal::RadosBucket(nullptr, info));
const auto rc = lua::request::execute(nullptr, nullptr, nullptr, &s, nullptr, script);
ASSERT_EQ(rc, 0);
DEFINE_REQ_STATE;
s.user.reset(new sal::RadosUser(nullptr, rgw_user("tenant1", "user1")));
- rgw_bucket b;
- b.name = "bucket1";
- s.bucket.reset(new sal::RadosBucket(nullptr, b));
- s.bucket->set_owner(new sal::RadosUser(nullptr, rgw_user("tenant2", "user2")));
+ RGWBucketInfo info;
+ info.bucket.name = "bucket1";
+ info.owner.id = "user2";
+ info.owner.tenant = "tenant2";
+ s.bucket.reset(new sal::RadosBucket(nullptr, info));
const auto rc = lua::request::execute(nullptr, nullptr, nullptr, &s, nullptr, script);
ASSERT_EQ(rc, 0);
projects / ceph.git / commitdiff