// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
-// vim: ts=8 sw=2 smarttab
+// vim: ts=8 sw=2 smarttab ft=cpp
#ifndef RGW_FILE_H
#define RGW_FILE_H
(void) fh_lru.unref(fh, cohort::lru::FLAG_NONE);
}
- int authorize(RGWRados* store) {
- int ret = rgw_get_user_info_by_access_key(store, key.id, user);
+ int authorize(rgw::sal::RGWRadosStore* store) {
+ int ret = store->ctl()->user->get_info_by_access_key(key.id, &user, null_yield);
if (ret == 0) {
RGWAccessKey* k = user.get_key(key.id);
if (!k || (k->key != key.key))
}
if (token.valid() && (ldh->auth(token.id, token.key) == 0)) {
/* try to store user if it doesn't already exist */
- if (rgw_get_user_info_by_uid(store, token.id, user) < 0) {
- int ret = rgw_store_user_info(store, user, NULL, NULL, real_time(),
- true);
+ if (store->ctl()->user->get_info_by_uid(rgw_user(token.id), &user, null_yield) < 0) {
+ int ret = store->ctl()->user->store_info(user, null_yield,
+ RGWUserCtl::PutParams()
+ .set_exclusive(true));
if (ret < 0) {
lsubdout(get_context(), rgw, 10)
<< "NOTICE: failed to store new user's info: ret=" << ret
void update_user() {
RGWUserInfo _user = user;
- int ret = rgw_get_user_info_by_access_key(rgwlib.get_store(), key.id, user);
+ auto user_ctl = rgwlib.get_store()->ctl()->user;
+ int ret = user_ctl->get_info_by_access_key(key.id, &user, null_yield);
if (ret != 0)
user = _user;
}
uint32_t d_count;
bool rcb_eof; // caller forced early stop in readdir cycle
- RGWListBucketsRequest(CephContext* _cct, RGWUserInfo *_user,
+ RGWListBucketsRequest(CephContext* _cct, rgw::sal::RGWUser *_user,
RGWFileHandle* _rgw_fh, rgw_readdir_cb _rcb,
void* _cb_arg, RGWFileHandle::readdir_offset& _offset)
: RGWLibRequest(_cct, _user), rgw_fh(_rgw_fh), offset(_offset),
// woo
s->user = user;
- s->bucket_tenant = user->user_id.tenant;
+ s->bucket_tenant = user->get_tenant();
return 0;
}
sent_data = true;
}
- void send_response_data(RGWUserBuckets& buckets) override {
+ void send_response_data(rgw::sal::RGWBucketList& buckets) override {
if (!sent_data)
return;
- map<string, RGWBucketEnt>& m = buckets.get_buckets();
+ map<string, rgw::sal::RGWBucket*>& m = buckets.get_buckets();
for (const auto& iter : m) {
boost::string_ref marker{iter.first};
- const RGWBucketEnt& ent = iter.second;
- if (! this->operator()(ent.bucket.name, marker)) {
+ rgw::sal::RGWBucket* ent = iter.second;
+ if (! this->operator()(ent->get_name(), marker)) {
/* caller cannot accept more */
lsubdout(cct, rgw, 5) << "ListBuckets rcb failed"
- << " dirent=" << ent.bucket.name
+ << " dirent=" << ent->get_name()
<< " call count=" << ix
<< dendl;
rcb_eof = true;
uint32_t d_count;
bool rcb_eof; // caller forced early stop in readdir cycle
- RGWReaddirRequest(CephContext* _cct, RGWUserInfo *_user,
+ RGWReaddirRequest(CephContext* _cct, rgw::sal::RGWUser *_user,
RGWFileHandle* _rgw_fh, rgw_readdir_cb _rcb,
void* _cb_arg, RGWFileHandle::readdir_offset& _offset)
: RGWLibRequest(_cct, _user), rgw_fh(_rgw_fh), offset(_offset),
// woo
s->user = user;
- s->bucket_tenant = user->user_id.tenant;
+ s->bucket_tenant = user->get_tenant();
prefix = rgw_fh->relative_object_name();
if (prefix.length() > 0)
bool valid;
bool has_children;
- RGWRMdirCheck (CephContext* _cct, RGWUserInfo *_user,
+ RGWRMdirCheck (CephContext* _cct, rgw::sal::RGWUser *_user,
const RGWFileHandle* _rgw_fh)
: RGWLibRequest(_cct, _user), rgw_fh(_rgw_fh), valid(false),
has_children(false) {
s->info.domain = ""; /* XXX ? */
s->user = user;
- s->bucket_tenant = user->user_id.tenant;
+ s->bucket_tenant = user->get_tenant();
prefix = rgw_fh->relative_object_name();
if (prefix.length() > 0)
public:
const std::string& bucket_name;
- RGWCreateBucketRequest(CephContext* _cct, RGWUserInfo *_user,
+ RGWCreateBucketRequest(CephContext* _cct, rgw::sal::RGWUser *_user,
std::string& _bname)
: RGWLibRequest(_cct, _user), bucket_name(_bname) {
op = this;
// woo
s->user = user;
- s->bucket_tenant = user->user_id.tenant;
+ s->bucket_tenant = user->get_tenant();
return 0;
}
public:
const std::string& bucket_name;
- RGWDeleteBucketRequest(CephContext* _cct, RGWUserInfo *_user,
+ RGWDeleteBucketRequest(CephContext* _cct, rgw::sal::RGWUser *_user,
std::string& _bname)
: RGWLibRequest(_cct, _user), bucket_name(_bname) {
op = this;
// woo
s->user = user;
- s->bucket_tenant = user->user_id.tenant;
+ s->bucket_tenant = user->get_tenant();
return 0;
}
buffer::list& bl; /* XXX */
size_t bytes_written;
- RGWPutObjRequest(CephContext* _cct, RGWUserInfo *_user,
+ RGWPutObjRequest(CephContext* _cct, rgw::sal::RGWUser *_user,
const std::string& _bname, const std::string& _oname,
buffer::list& _bl)
: RGWLibRequest(_cct, _user), bucket_name(_bname), obj_name(_oname),
// woo
s->user = user;
- s->bucket_tenant = user->user_id.tenant;
+ s->bucket_tenant = user->get_tenant();
return 0;
}
size_t read_resid; /* initialize to len, <= sizeof(ulp_buffer) */
bool do_hexdump = false;
- RGWReadRequest(CephContext* _cct, RGWUserInfo *_user,
+ RGWReadRequest(CephContext* _cct, rgw::sal::RGWUser *_user,
RGWFileHandle* _rgw_fh, uint64_t off, uint64_t len,
void *_ulp_buffer)
: RGWLibRequest(_cct, _user), rgw_fh(_rgw_fh), ulp_buffer(_ulp_buffer),
// woo
s->user = user;
- s->bucket_tenant = user->user_id.tenant;
+ s->bucket_tenant = user->get_tenant();
return 0;
}
const std::string& bucket_name;
const std::string& obj_name;
- RGWDeleteObjRequest(CephContext* _cct, RGWUserInfo *_user,
+ RGWDeleteObjRequest(CephContext* _cct, rgw::sal::RGWUser *_user,
const std::string& _bname, const std::string& _oname)
: RGWLibRequest(_cct, _user), bucket_name(_bname), obj_name(_oname) {
op = this;
// woo
s->user = user;
- s->bucket_tenant = user->user_id.tenant;
+ s->bucket_tenant = user->get_tenant();
return 0;
}
static constexpr uint32_t FLAG_NONE = 0x000;
- RGWStatObjRequest(CephContext* _cct, RGWUserInfo *_user,
+ RGWStatObjRequest(CephContext* _cct, rgw::sal::RGWUser *_user,
const std::string& _bname, const std::string& _oname,
uint32_t _flags)
: RGWLibRequest(_cct, _user), bucket_name(_bname), obj_name(_oname),
// woo
s->user = user;
- s->bucket_tenant = user->user_id.tenant;
+ s->bucket_tenant = user->get_tenant();
return 0;
}
std::map<std::string, buffer::list> attrs;
RGWLibFS::BucketStats& bs;
- RGWStatBucketRequest(CephContext* _cct, RGWUserInfo *_user,
+ RGWStatBucketRequest(CephContext* _cct, rgw::sal::RGWUser *_user,
const std::string& _path,
RGWLibFS::BucketStats& _stats)
: RGWLibRequest(_cct, _user), bs(_stats) {
}
real_time get_ctime() const {
- return bucket.creation_time;
+ return bucket->get_creation_time();
}
bool only_bucket() override { return false; }
// woo
s->user = user;
- s->bucket_tenant = user->user_id.tenant;
+ s->bucket_tenant = user->get_tenant();
return 0;
}
}
void send_response() override {
- bucket.creation_time = get_state()->bucket_info.creation_time;
- bs.size = bucket.size;
- bs.size_rounded = bucket.size_rounded;
- bs.creation_time = bucket.creation_time;
- bs.num_entries = bucket.count;
+ bucket->get_creation_time() = get_state()->bucket_info.creation_time;
+ bs.size = bucket->get_size();
+ bs.size_rounded = bucket->get_size_rounded();
+ bs.creation_time = bucket->get_creation_time();
+ bs.num_entries = bucket->get_count();
std::swap(attrs, get_state()->bucket_attrs);
}
bool matched() {
- return (bucket.bucket.name.length() > 0);
+ return (bucket->get_name().length() > 0);
}
}; /* RGWStatBucketRequest */
bool is_dir;
bool exact_matched;
- RGWStatLeafRequest(CephContext* _cct, RGWUserInfo *_user,
+ RGWStatLeafRequest(CephContext* _cct, rgw::sal::RGWUser *_user,
RGWFileHandle* _rgw_fh, const std::string& _path)
: RGWLibRequest(_cct, _user), rgw_fh(_rgw_fh), path(_path),
matched(false), is_dir(false), exact_matched(false) {
// woo
s->user = user;
- s->bucket_tenant = user->user_id.tenant;
+ s->bucket_tenant = user->get_tenant();
prefix = rgw_fh->relative_object_name();
if (prefix.length() > 0)
const std::string& bucket_name;
const std::string& obj_name;
RGWFileHandle* rgw_fh;
- std::optional<rgw::AioThrottle> aio;
+ std::optional<rgw::BlockingAioThrottle> aio;
std::optional<rgw::putobj::AtomicObjectProcessor> processor;
rgw::putobj::DataProcessor* filter;
boost::optional<RGWPutObj_Compress> compressor;
size_t bytes_written;
bool eio;
- RGWWriteRequest(CephContext* _cct, RGWUserInfo *_user, RGWFileHandle* _fh,
+ RGWWriteRequest(CephContext* _cct, rgw::sal::RGWUser *_user, RGWFileHandle* _fh,
const std::string& _bname, const std::string& _oname)
: RGWLibContinuedReq(_cct, _user),
bucket_name(_bname), obj_name(_oname),
// woo
s->user = user;
- s->bucket_tenant = user->user_id.tenant;
+ s->bucket_tenant = user->get_tenant();
return 0;
}
const std::string& src_name;
const std::string& dst_name;
- RGWCopyObjRequest(CephContext* _cct, RGWUserInfo *_user,
+ RGWCopyObjRequest(CephContext* _cct, rgw::sal::RGWUser *_user,
RGWFileHandle* _src_parent, RGWFileHandle* _dst_parent,
const std::string& _src_name, const std::string& _dst_name)
: RGWLibRequest(_cct, _user), src_parent(_src_parent),
// woo
s->user = user;
- s->bucket_tenant = user->user_id.tenant;
+ s->bucket_tenant = user->get_tenant();
return 0;
}
const std::string& bucket_name;
const std::string& obj_name;
- RGWSetAttrsRequest(CephContext* _cct, RGWUserInfo *_user,
+ RGWSetAttrsRequest(CephContext* _cct, rgw::sal::RGWUser *_user,
const std::string& _bname, const std::string& _oname)
: RGWLibRequest(_cct, _user), bucket_name(_bname), obj_name(_oname) {
op = this;
// woo
s->user = user;
- s->bucket_tenant = user->user_id.tenant;
+ s->bucket_tenant = user->get_tenant();
return 0;
}
public RGWGetClusterStat {
public:
struct rados_cluster_stat_t& stats_req;
- RGWGetClusterStatReq(CephContext* _cct,RGWUserInfo *_user,
+ RGWGetClusterStatReq(CephContext* _cct,rgw::sal::RGWUser *_user,
rados_cluster_stat_t& _stats):
RGWLibRequest(_cct, _user), stats_req(_stats){
op = this;