#include "rgw_compression.h"
#include "rgw_auth.h"
+#include "rgw_auth_registry.h"
#include "rgw_swift_auth.h"
#include "rgw_request.h"
return 0;
}
-static void dump_account_metadata(struct req_state * const s,
+static void dump_account_metadata(req_state * const s,
const RGWUsageStats& global_stats,
const std::map<std::string, RGWUsageStats> &policies_stats,
/* const */map<string, bufferlist>& attrs,
{
if (op_ret) {
set_req_state_err(s, op_ret);
- } else if (!has_buckets && s->format == RGW_FORMAT_PLAIN) {
+ } else if (!has_buckets && s->format == RGWFormat::PLAIN) {
op_ret = STATUS_NO_CONTENT;
set_req_state_err(s, op_ret);
}
global_stats,
policies_stats,
s->user->get_attrs(),
- s->user->get_info().user_quota,
+ s->user->get_info().quota.user_quota,
static_cast<RGWAccessControlPolicy_SWIFTAcct&>(*s->user_acl));
dump_errno(s);
dump_header(s, "Accept-Ranges", "bytes");
global_stats,
policies_stats,
s->user->get_attrs(),
- s->user->get_info().user_quota,
+ s->user->get_info().quota.user_quota,
static_cast<RGWAccessControlPolicy_SWIFTAcct&>(*s->user_acl));
dump_errno(s);
end_header(s, nullptr, nullptr, s->formatter->get_len(), true);
return 0;
}
-static void dump_container_metadata(struct req_state *,
+static void dump_container_metadata(req_state *,
const rgw::sal::Bucket*,
const RGWQuotaInfo&,
const RGWBucketWebsiteConf&);
map<string, bool>::iterator pref_iter = common_prefixes.begin();
dump_start(s);
- dump_container_metadata(s, s->bucket.get(), bucket_quota,
+ dump_container_metadata(s, s->bucket.get(), quota.bucket_quota,
s->bucket->get_info().website_conf);
s->formatter->open_array_section_with_attrs("container",
/* swift is a bit inconsistent here */
switch (s->format) {
- case RGW_FORMAT_XML:
+ case RGWFormat::XML:
s->formatter->dump_string("name", name);
break;
default:
rgw_flush_formatter_and_reset(s, s->formatter);
} // RGWListBucket_ObjStore_SWIFT::send_response
-static void dump_container_metadata(struct req_state *s,
+static void dump_container_metadata(req_state *s,
const rgw::sal::Bucket* bucket,
const RGWQuotaInfo& quota,
const RGWBucketWebsiteConf& ws_conf)
global_stats,
policies_stats,
attrs,
- s->user->get_info().user_quota,
+ s->user->get_info().quota.user_quota,
static_cast<RGWAccessControlPolicy_SWIFTAcct&>(*s->user_acl));
}
{
if (op_ret >= 0) {
op_ret = STATUS_NO_CONTENT;
- dump_container_metadata(s, bucket.get(), bucket_quota,
+ dump_container_metadata(s, bucket.get(), quota.bucket_quota,
s->bucket->get_info().website_conf);
}
}
static int get_swift_container_settings(req_state * const s,
- rgw::sal::Store* const store,
+ rgw::sal::Driver* const driver,
RGWAccessControlPolicy * const policy,
bool * const has_policy,
uint32_t * rw_mask,
if (read_list || write_list) {
RGWAccessControlPolicy_SWIFT swift_policy(s->cct);
- const auto r = swift_policy.create(s, store,
+ const auto r = swift_policy.create(s, driver,
s->user->get_id(),
s->user->get_display_name(),
read_list,
bool has_policy;
uint32_t policy_rw_mask = 0;
- int r = get_swift_container_settings(s, store, &policy, &has_policy,
+ int r = get_swift_container_settings(s, driver, &policy, &has_policy,
&policy_rw_mask, &cors_config, &has_cors);
if (r < 0) {
return r;
policy.create_default(s->user->get_id(), s->user->get_display_name());
}
- location_constraint = store->get_zone()->get_zonegroup().api_name;
+ location_constraint = driver->get_zone()->get_zonegroup().get_api_name();
get_rmattrs_from_headers(s, CONT_PUT_ATTR_PREFIX,
CONT_REMOVE_ATTR_PREFIX, rmattr_names);
placement_rule.init(s->info.env->get("HTTP_X_STORAGE_POLICY", ""), s->info.storage_class);
std::unique_ptr<rgw::sal::Bucket> bucket;
if (bucket_name.compare(s->bucket->get_name()) != 0) {
- r = store->get_bucket(s, s->user.get(), s->user->get_id().tenant, bucket_name, &bucket, s->yield);
+ r = driver->get_bucket(s, s->user.get(), s->user->get_id().tenant, bucket_name, &bucket, s->yield);
if (r < 0) {
ldpp_dout(this, 0) << "could not get bucket info for bucket="
<< bucket_name << dendl;
std::unique_ptr<rgw::sal::Object> slo_seg = bucket->get_object(rgw_obj_key(obj_name));
/* no prefetch */
- RGWObjectCtx obj_ctx(store);
- slo_seg->set_atomic(&obj_ctx);
+ slo_seg->set_atomic();
bool compressed;
RGWCompressionInfo cs_info;
uint64_t size_bytes{0};
- r = slo_seg->get_obj_attrs(&obj_ctx, s->yield, s);
+ r = slo_seg->get_obj_attrs(s->yield, s);
if (r < 0) {
return r;
}
}
static int get_swift_account_settings(req_state * const s,
- rgw::sal::Store* const store,
+ rgw::sal::Driver* const driver,
RGWAccessControlPolicy_SWIFTAcct* const policy,
bool * const has_policy)
{
const char * const acl_attr = s->info.env->get("HTTP_X_ACCOUNT_ACCESS_CONTROL");
if (acl_attr) {
RGWAccessControlPolicy_SWIFTAcct swift_acct_policy(s->cct);
- const bool r = swift_acct_policy.create(s, store,
+ const bool r = swift_acct_policy.create(s, driver,
s->user->get_id(),
s->user->get_display_name(),
string(acl_attr));
}
int ret = get_swift_account_settings(s,
- store,
+ driver,
// FIXME: we need to carry unique_ptr in generic class
// and allocate appropriate ACL class in the ctor
static_cast<RGWAccessControlPolicy_SWIFTAcct *>(&policy),
return -EINVAL;
}
- int r = get_swift_container_settings(s, store, &policy, &has_policy,
+ int r = get_swift_container_settings(s, driver, &policy, &has_policy,
&policy_rw_mask, &cors_config, &has_cors);
if (r < 0) {
return r;
}
}
-static void dump_object_metadata(const DoutPrefixProvider* dpp, struct req_state * const s,
+static void dump_object_metadata(const DoutPrefixProvider* dpp, req_state * const s,
const map<string, bufferlist>& attrs)
{
map<string, string> response_attrs;
if_match = s->info.env->get("HTTP_COPY_IF_MATCH");
if_nomatch = s->info.env->get("HTTP_COPY_IF_NONE_MATCH");
- src_tenant_name = s->src_tenant_name;
- src_bucket_name = s->src_bucket_name;
- dest_tenant_name = s->bucket_tenant;
- dest_bucket_name = s->bucket_name;
- dest_obj_name = s->object->get_name();
-
const char * const fresh_meta = s->info.env->get("HTTP_X_FRESH_METADATA");
if (fresh_meta && strcasecmp(fresh_meta, "TRUE") == 0) {
attrs_mod = rgw::sal::ATTRSMOD_REPLACE;
s->formatter->close_section();
}
else {
- pair.second.list_data(*(s->formatter), s->cct->_conf, store);
+ pair.second.list_data(*(s->formatter), s->cct->_conf, driver);
}
}
void RGWInfo_ObjStore_SWIFT::list_swift_data(Formatter& formatter,
const ConfigProxy& config,
- rgw::sal::Store* store)
+ rgw::sal::Driver* driver)
{
formatter.open_object_section("swift");
formatter.dump_int("max_file_size", config->rgw_max_put_size);
}
formatter.open_array_section("policies");
- const RGWZoneGroup& zonegroup = store->get_zone()->get_zonegroup();
+ const rgw::sal::ZoneGroup& zonegroup = driver->get_zone()->get_zonegroup();
- for (const auto& placement_targets : zonegroup.placement_targets) {
- formatter.open_object_section("policy");
- if (placement_targets.second.name.compare(zonegroup.default_placement.name) == 0)
- formatter.dump_bool("default", true);
- formatter.dump_string("name", placement_targets.second.name.c_str());
- formatter.close_section();
+ std::set<std::string> targets;
+ if (zonegroup.get_placement_target_names(targets)) {
+ for (const auto& placement_targets : targets) {
+ formatter.open_object_section("policy");
+ if (placement_targets.compare(zonegroup.get_default_placement_name()) == 0)
+ formatter.dump_bool("default", true);
+ formatter.dump_string("name", placement_targets.c_str());
+ formatter.close_section();
+ }
}
formatter.close_section();
void RGWInfo_ObjStore_SWIFT::list_tempauth_data(Formatter& formatter,
const ConfigProxy& config,
- rgw::sal::Store* store)
+ rgw::sal::Driver* driver)
{
formatter.open_object_section("tempauth");
formatter.dump_bool("account_acls", true);
}
void RGWInfo_ObjStore_SWIFT::list_tempurl_data(Formatter& formatter,
const ConfigProxy& config,
- rgw::sal::Store* store)
+ rgw::sal::Driver* driver)
{
formatter.open_object_section("tempurl");
formatter.open_array_section("methods");
void RGWInfo_ObjStore_SWIFT::list_slo_data(Formatter& formatter,
const ConfigProxy& config,
- rgw::sal::Store* store)
+ rgw::sal::Driver* driver)
{
formatter.open_object_section("slo");
formatter.dump_int("max_manifest_segments", config->rgw_max_slo_entries);
}
-void RGWFormPost::init(rgw::sal::Store* const store,
+void RGWFormPost::init(rgw::sal::Driver* const driver,
req_state* const s,
RGWHandler* const dialect_handler)
{
- prefix = std::move(s->object->get_name());
- s->object->set_key(rgw_obj_key());
+ if (!rgw::sal::Object::empty(s->object)) {
+ prefix = std::move(s->object->get_name());
+ s->object->set_key(rgw_obj_key());
+ }
- return RGWPostObj_ObjStore::init(store, s, dialect_handler);
+ return RGWPostObj_ObjStore::init(driver, s, dialect_handler);
}
std::size_t RGWFormPost::get_max_file_size() /*const*/
}
const utime_t now = ceph_clock_now();
- if (expires_timestamp <= static_cast<uint64_t>(now.sec())) {
+ if (std::cmp_less_equal(expires_timestamp, now.sec())) {
ldpp_dout(this, 5) << "FormPost form expired: "
<< expires_timestamp << " <= " << now.sec() << dendl;
return false;
const rgw_user uid(s->account_name);
if (uid.tenant.empty()) {
const rgw_user tenanted_uid(uid.id, uid.id);
- user = store->get_user(tenanted_uid);
+ user = driver->get_user(tenanted_uid);
if (user->load_user(s, s->yield) >= 0) {
/* Succeeded. */
}
if (!found) {
- user = store->get_user(uid);
+ user = driver->get_user(uid);
if (user->load_user(s, s->yield) < 0) {
throw -EPERM;
}
/* Need to get user info of bucket owner. */
std::unique_ptr<rgw::sal::Bucket> bucket;
- int ret = store->get_bucket(s, user.get(), user->get_tenant(), bucket_name, &bucket, s->yield);
+ int ret = driver->get_bucket(s, user.get(), user->get_tenant(), bucket_name, &bucket, s->yield);
if (ret < 0) {
throw ret;
}
ldpp_dout(this, 20) << "temp url user (bucket owner): " << bucket->get_info().owner
<< dendl;
- user = store->get_user(bucket->get_info().owner);
+ user = driver->get_user(bucket->get_info().owner);
if (user->load_user(s, s->yield) < 0) {
throw -EPERM;
}
* only. They will be picked up by ::get_data(). */
break;
} else {
- /* Control part ahead. Receive, parse and store for later usage. */
+ /* Control part ahead. Receive, parse and driver for later usage. */
bool boundary;
ret = read_data(part.data, s->cct->_conf->rgw_max_chunk_size,
boundary, stream_done);
class RGWGetErrorPage : public RGWGetObj_ObjStore_SWIFT {
public:
- RGWGetErrorPage(rgw::sal::Store* const store,
+ RGWGetErrorPage(rgw::sal::Driver* const driver,
RGWHandler_REST* const handler,
req_state* const s,
const int http_ret) {
/* Calling a virtual from the base class is safe as the subobject should
* be properly initialized and we haven't overridden the init method. */
- init(store, s, handler);
+ init(driver, s, handler);
set_get_data(true);
set_custom_http_response(http_ret);
}
* fault situation by sending the original message. */
return 0;
}
- } get_errpage_op(store, handler, s, http_ret);
+ } get_errpage_op(driver, handler, s, http_ret);
/* This is okay. It's an error, so nothing will run after this, and it can be
* called by abort_early(), which can be called before s->object or s->bucket
if (!rgw::sal::Bucket::empty(s->bucket.get())) {
s->object = s->bucket->get_object(rgw_obj_key(std::to_string(http_ret) + error_doc));
} else {
- s->object = store->get_object(rgw_obj_key(std::to_string(http_ret) + error_doc));
+ s->object = driver->get_object(rgw_obj_key(std::to_string(http_ret) + error_doc));
}
RGWOp* newop = &get_errpage_op;
RGWRequest req(0);
- return rgw_process_authenticated(handler, newop, &req, s, y, store, true);
+ return rgw_process_authenticated(handler, newop, &req, s, y, driver, true);
}
int RGWSwiftWebsiteHandler::error_handler(const int err_no,
} else {
s->object->set_name(s->bucket->get_info().website_conf.get_index_doc());
}
- s->object->set_bucket(s->bucket.get());
auto getop = new RGWGetObj_ObjStore_SWIFT;
getop->set_get_data(boost::algorithm::equals("GET", s->info.method));
/* Generate the header now. */
set_req_state_err(s, op_ret);
dump_errno(s);
- dump_container_metadata(s, s->bucket.get(), bucket_quota,
+ dump_container_metadata(s, s->bucket.get(), quota.bucket_quota,
s->bucket->get_info().website_conf);
end_header(s, this, "text/html");
if (op_ret < 0) {
std::unique_ptr<rgw::sal::Object> obj = s->bucket->get_object(rgw_obj_key(std::move(subdir_name)));
/* First, get attrset of the object we'll try to retrieve. */
- RGWObjectCtx& obj_ctx = *static_cast<RGWObjectCtx *>(s->obj_ctx);
- obj->set_atomic(&obj_ctx);
- obj->set_prefetch_data(&obj_ctx);
+ obj->set_atomic();
+ obj->set_prefetch_data();
RGWObjState* state = nullptr;
- if (obj->get_obj_state(s, &obj_ctx, &state, s->yield, false)) {
+ if (obj->get_obj_state(s, &state, s->yield, false)) {
return false;
}
{
std::unique_ptr<rgw::sal::Object> obj = s->bucket->get_object(rgw_obj_key(index));
- RGWObjectCtx& obj_ctx = *static_cast<RGWObjectCtx *>(s->obj_ctx);
- obj->set_atomic(&obj_ctx);
- obj->set_prefetch_data(&obj_ctx);
+ obj->set_atomic();
+ obj->set_prefetch_data();
RGWObjState* state = nullptr;
- if (obj->get_obj_state(s, &obj_ctx, &state, s->yield, false)) {
+ if (obj->get_obj_state(s, &state, s->yield, false)) {
return false;
}
if (op_override) {
handler->put_op(op);
- op_override->init(store, s, handler);
+ op_override->init(driver, s, handler);
*new_op = op_override;
} else {
if (op_override) {
handler->put_op(op);
- op_override->init(store, s, handler);
+ op_override->init(driver, s, handler);
*new_op = op_override;
} else {
if (!s->object) {
/* Need an object, even an empty one */
- s->object = store->get_object(rgw_obj_key());
+ s->object = driver->get_object(rgw_obj_key());
}
ldpp_dout(s, 10) << "s->object=" <<
}
}
-int RGWHandler_REST_SWIFT::init_from_header(rgw::sal::Store* store,
- struct req_state* const s,
+int RGWHandler_REST_SWIFT::init_from_header(rgw::sal::Driver* driver,
+ req_state* const s,
const std::string& frontend_prefix)
{
string req;
return -ENOENT;
}
- int ret = allocate_formatter(s, RGW_FORMAT_PLAIN, true);
+ int ret = allocate_formatter(s, RGWFormat::PLAIN, true);
if (ret < 0)
return ret;
s->init_state.url_bucket = first;
if (req.size()) {
- s->object = store->get_object(
+ s->object = driver->get_object(
rgw_obj_key(req, s->info.env->get("HTTP_X_OBJECT_VERSION_ID", ""))); /* rgw swift extension */
s->info.effective_uri.append("/" + s->object->get_name());
}
return 0;
}
-int RGWHandler_REST_SWIFT::init(rgw::sal::Store* store, struct req_state* s,
+int RGWHandler_REST_SWIFT::init(rgw::sal::Driver* driver, req_state* s,
rgw::io::BasicClient *cio)
{
struct req_init_state *t = &s->init_state;
bool result = RGWCopyObj::parse_copy_location(copy_source, t->src_bucket, key, s);
if (!result)
return -ERR_BAD_URL;
- s->src_object = store->get_object(key);
+ s->src_object = driver->get_object(key);
if (!s->src_object)
return -ERR_BAD_URL;
}
s->info.storage_class = s->info.env->get("HTTP_X_OBJECT_STORAGE_CLASS", "");
- return RGWHandler_REST::init(store, s, cio);
+ return RGWHandler_REST::init(driver, s, cio);
}
RGWHandler_REST*
-RGWRESTMgr_SWIFT::get_handler(rgw::sal::Store* store,
- struct req_state* const s,
+RGWRESTMgr_SWIFT::get_handler(rgw::sal::Driver* driver,
+ req_state* const s,
const rgw::auth::StrategyRegistry& auth_registry,
const std::string& frontend_prefix)
{
- int ret = RGWHandler_REST_SWIFT::init_from_header(store, s, frontend_prefix);
+ int ret = RGWHandler_REST_SWIFT::init_from_header(driver, s, frontend_prefix);
if (ret < 0) {
ldpp_dout(s, 10) << "init_from_header returned err=" << ret << dendl;
return nullptr;
}
RGWHandler_REST* RGWRESTMgr_SWIFT_Info::get_handler(
- rgw::sal::Store* store,
- struct req_state* const s,
+ rgw::sal::Driver* driver,
+ req_state* const s,
const rgw::auth::StrategyRegistry& auth_registry,
const std::string& frontend_prefix)
{
projects / ceph.git / blobdiff