repo
stringlengths 1
152
⌀ | file
stringlengths 15
205
| code
stringlengths 0
41.6M
| file_length
int64 0
41.6M
| avg_line_length
float64 0
1.81M
| max_line_length
int64 0
12.7M
| extension_type
stringclasses 90
values |
|---|---|---|---|---|---|---|
null |
ceph-main/src/rgw/rgw_rest_admin.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#pragma once
#include "rgw/rgw_rest.h"
class RGWRESTMgr_Admin : public RGWRESTMgr {
public:
RGWRESTMgr_Admin() {}
~RGWRESTMgr_Admin() override {}
};
| 261 | 19.153846 | 70 |
h
|
null |
ceph-main/src/rgw/rgw_rest_client.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#include "rgw_common.h"
#include "rgw_rest_client.h"
#include "rgw_auth_s3.h"
#include "rgw_http_errors.h"
#include "common/armor.h"
#include "common/strtol.h"
#include "include/str_list.h"
#include "rgw_crypt_sanitize.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rgw
using namespace std;
int RGWHTTPSimpleRequest::get_status()
{
int retcode = get_req_retcode();
if (retcode < 0) {
return retcode;
}
return status;
}
int RGWHTTPSimpleRequest::handle_header(const string& name, const string& val)
{
if (name == "CONTENT_LENGTH") {
string err;
long len = strict_strtol(val.c_str(), 10, &err);
if (!err.empty()) {
ldpp_dout(this, 0) << "ERROR: failed converting content length (" << val << ") to int " << dendl;
return -EINVAL;
}
max_response = len;
}
return 0;
}
int RGWHTTPSimpleRequest::receive_header(void *ptr, size_t len)
{
unique_lock guard(out_headers_lock);
char line[len + 1];
char *s = (char *)ptr, *end = (char *)ptr + len;
char *p = line;
ldpp_dout(this, 30) << "receive_http_header" << dendl;
while (s != end) {
if (*s == '\r') {
s++;
continue;
}
if (*s == '\n') {
*p = '\0';
ldpp_dout(this, 30) << "received header:" << line << dendl;
// TODO: fill whatever data required here
char *l = line;
char *tok = strsep(&l, " \t:");
if (tok && l) {
while (*l == ' ')
l++;
if (strcmp(tok, "HTTP") == 0 || strncmp(tok, "HTTP/", 5) == 0) {
http_status = atoi(l);
if (http_status == 100) /* 100-continue response */
continue;
status = rgw_http_error_to_errno(http_status);
} else {
/* convert header field name to upper case */
char *src = tok;
char buf[len + 1];
size_t i;
for (i = 0; i < len && *src; ++i, ++src) {
switch (*src) {
case '-':
buf[i] = '_';
break;
default:
buf[i] = toupper(*src);
}
}
buf[i] = '\0';
out_headers[buf] = l;
int r = handle_header(buf, l);
if (r < 0)
return r;
}
}
}
if (s != end)
*p++ = *s++;
}
return 0;
}
static void get_new_date_str(string& date_str)
{
date_str = rgw_to_asctime(ceph_clock_now());
}
static void get_gmt_date_str(string& date_str)
{
auto now_time = ceph::real_clock::now();
time_t rawtime = ceph::real_clock::to_time_t(now_time);
char buffer[80];
struct tm timeInfo;
gmtime_r(&rawtime, &timeInfo);
strftime(buffer, sizeof(buffer), "%a, %d %b %Y %H:%M:%S %z", &timeInfo);
date_str = buffer;
}
int RGWHTTPSimpleRequest::send_data(void *ptr, size_t len, bool* pause)
{
if (!send_iter)
return 0;
if (len > send_iter->get_remaining())
len = send_iter->get_remaining();
send_iter->copy(len, (char *)ptr);
return len;
}
int RGWHTTPSimpleRequest::receive_data(void *ptr, size_t len, bool *pause)
{
size_t cp_len, left_len;
left_len = max_response > response.length() ? (max_response - response.length()) : 0;
if (left_len == 0)
return 0; /* don't read extra data */
cp_len = (len > left_len) ? left_len : len;
bufferptr p((char *)ptr, cp_len);
response.append(p);
return 0;
}
static void append_param(string& dest, const string& name, const string& val)
{
if (dest.empty()) {
dest.append("?");
} else {
dest.append("&");
}
string url_name;
url_encode(name, url_name);
dest.append(url_name);
if (!val.empty()) {
string url_val;
url_encode(val, url_val);
dest.append("=");
dest.append(url_val);
}
}
static void do_get_params_str(const param_vec_t& params, map<string, string>& extra_args, string& dest)
{
map<string, string>::iterator miter;
for (miter = extra_args.begin(); miter != extra_args.end(); ++miter) {
append_param(dest, miter->first, miter->second);
}
for (auto iter = params.begin(); iter != params.end(); ++iter) {
append_param(dest, iter->first, iter->second);
}
}
void RGWHTTPSimpleRequest::get_params_str(map<string, string>& extra_args, string& dest)
{
do_get_params_str(params, extra_args, dest);
}
void RGWHTTPSimpleRequest::get_out_headers(map<string, string> *pheaders)
{
unique_lock guard(out_headers_lock);
pheaders->swap(out_headers);
out_headers.clear();
}
static int sign_request_v2(const DoutPrefixProvider *dpp, const RGWAccessKey& key,
const string& region, const string& service,
RGWEnv& env, req_info& info,
const bufferlist *opt_content)
{
/* don't sign if no key is provided */
if (key.key.empty()) {
return 0;
}
auto cct = dpp->get_cct();
if (cct->_conf->subsys.should_gather<ceph_subsys_rgw, 20>()) {
for (const auto& i: env.get_map()) {
ldpp_dout(dpp, 20) << __func__ << "():> " << i.first << " -> " << rgw::crypt_sanitize::x_meta_map{i.first, i.second} << dendl;
}
}
string canonical_header;
if (!rgw_create_s3_canonical_header(dpp, info, NULL, canonical_header, false)) {
ldpp_dout(dpp, 0) << "failed to create canonical s3 header" << dendl;
return -EINVAL;
}
ldpp_dout(dpp, 10) << "generated canonical header: " << canonical_header << dendl;
string digest;
try {
digest = rgw::auth::s3::get_v2_signature(cct, key.key, canonical_header);
} catch (int ret) {
return ret;
}
string auth_hdr = "AWS " + key.id + ":" + digest;
ldpp_dout(dpp, 15) << "generated auth header: " << auth_hdr << dendl;
env.set("AUTHORIZATION", auth_hdr);
return 0;
}
static int sign_request_v4(const DoutPrefixProvider *dpp, const RGWAccessKey& key,
const string& region, const string& service,
RGWEnv& env, req_info& info,
const bufferlist *opt_content)
{
/* don't sign if no key is provided */
if (key.key.empty()) {
return 0;
}
auto cct = dpp->get_cct();
if (cct->_conf->subsys.should_gather<ceph_subsys_rgw, 20>()) {
for (const auto& i: env.get_map()) {
ldpp_dout(dpp, 20) << __func__ << "():> " << i.first << " -> " << rgw::crypt_sanitize::x_meta_map{i.first, i.second} << dendl;
}
}
rgw::auth::s3::AWSSignerV4::prepare_result_t sigv4_data;
if (service == "s3") {
sigv4_data = rgw::auth::s3::AWSSignerV4::prepare(dpp, key.id, region, service, info, opt_content, true);
} else {
sigv4_data = rgw::auth::s3::AWSSignerV4::prepare(dpp, key.id, region, service, info, opt_content, false);
}
auto sigv4_headers = sigv4_data.signature_factory(dpp, key.key, sigv4_data);
for (auto& entry : sigv4_headers) {
ldpp_dout(dpp, 20) << __func__ << "(): sigv4 header: " << entry.first << ": " << entry.second << dendl;
env.set(entry.first, entry.second);
}
return 0;
}
static int sign_request(const DoutPrefixProvider *dpp, const RGWAccessKey& key,
const string& region, const string& service,
RGWEnv& env, req_info& info,
const bufferlist *opt_content)
{
auto authv = dpp->get_cct()->_conf.get_val<int64_t>("rgw_s3_client_max_sig_ver");
if (authv > 0 &&
authv <= 3) {
return sign_request_v2(dpp, key, region, service, env, info, opt_content);
}
return sign_request_v4(dpp, key, region, service, env, info, opt_content);
}
static string extract_region_name(string&& s)
{
if (s == "s3") {
return "us-east-1";
}
if (boost::algorithm::starts_with(s, "s3-")) {
return s.substr(3);
}
return std::move(s);
}
static bool identify_scope(const DoutPrefixProvider *dpp,
CephContext *cct,
const string& host,
string *region,
string& service)
{
if (!boost::algorithm::ends_with(host, "amazonaws.com")) {
ldpp_dout(dpp, 20) << "NOTICE: cannot identify region for connection to: " << host << dendl;
return false;
}
vector<string> vec;
get_str_vec(host, ".", vec);
string ser = service;
if (service.empty()) {
service = "s3"; /* default */
}
for (auto iter = vec.begin(); iter != vec.end(); ++iter) {
auto& s = *iter;
if (s == "s3" ||
s == "execute-api" ||
s == "iam") {
if (s == "execute-api") {
service = s;
}
++iter;
if (iter == vec.end()) {
ldpp_dout(dpp, 0) << "WARNING: cannot identify region name from host name: " << host << dendl;
return false;
}
auto& next = *iter;
if (next == "amazonaws") {
*region = "us-east-1";
return true;
}
*region = next;
return true;
} else if (boost::algorithm::starts_with(s, "s3-")) {
*region = extract_region_name(std::move(s));
return true;
}
}
return false;
}
static void scope_from_api_name(const DoutPrefixProvider *dpp,
CephContext *cct,
const string& host,
std::optional<string> api_name,
string *region,
string& service)
{
if (api_name && service.empty()) {
*region = *api_name;
service = "s3";
return;
}
if (!identify_scope(dpp, cct, host, region, service)) {
if (service == "iam") {
*region = cct->_conf->rgw_zonegroup;
} else {
*region = cct->_conf->rgw_zonegroup;
service = "s3";
}
return;
}
}
int RGWRESTSimpleRequest::forward_request(const DoutPrefixProvider *dpp, const RGWAccessKey& key, req_info& info, size_t max_response, bufferlist *inbl, bufferlist *outbl, optional_yield y, std::string service)
{
string date_str;
get_new_date_str(date_str);
RGWEnv new_env;
req_info new_info(cct, &new_env);
new_info.rebuild_from(info);
string bucket_encode;
string request_uri_encode;
size_t pos = new_info.request_uri.substr(1, new_info.request_uri.size() - 1).find("/");
string bucket = new_info.request_uri.substr(1, pos);
url_encode(bucket, bucket_encode);
if (std::string::npos != pos)
request_uri_encode = string("/") + bucket_encode + new_info.request_uri.substr(pos + 1);
else
request_uri_encode = string("/") + bucket_encode;
new_info.request_uri = request_uri_encode;
for (auto& param : params) {
new_info.args.append(param.first, param.second);
}
new_env.set("HTTP_DATE", date_str.c_str());
const char* const content_md5 = info.env->get("HTTP_CONTENT_MD5");
if (content_md5) {
new_env.set("HTTP_CONTENT_MD5", content_md5);
}
string region;
string s;
if (!service.empty()) {
s = service;
}
scope_from_api_name(dpp, cct, host, api_name, ®ion, s);
const char *maybe_payload_hash = info.env->get("HTTP_X_AMZ_CONTENT_SHA256");
if (maybe_payload_hash && s != "iam") {
new_env.set("HTTP_X_AMZ_CONTENT_SHA256", maybe_payload_hash);
}
int ret = sign_request(dpp, key, region, s, new_env, new_info, nullptr);
if (ret < 0) {
ldpp_dout(dpp, 0) << "ERROR: failed to sign request" << dendl;
return ret;
}
if (s == "iam") {
info.args.remove("PayloadHash");
}
for (const auto& kv: new_env.get_map()) {
headers.emplace_back(kv);
}
meta_map_t& meta_map = new_info.x_meta_map;
for (const auto& kv: meta_map) {
headers.emplace_back(kv);
}
string params_str;
get_params_str(info.args.get_params(), params_str);
string new_url = url;
string& resource = new_info.request_uri;
string new_resource = resource;
if (new_url[new_url.size() - 1] == '/' && resource[0] == '/') {
new_url = new_url.substr(0, new_url.size() - 1);
} else if (resource[0] != '/') {
new_resource = "/";
new_resource.append(resource);
}
new_url.append(new_resource + params_str);
bufferlist::iterator bliter;
if (inbl) {
bliter = inbl->begin();
send_iter = &bliter;
set_send_length(inbl->length());
}
method = new_info.method;
url = new_url;
int r = process(y);
if (r < 0){
if (r == -EINVAL){
// curl_easy has errored, generally means the service is not available
r = -ERR_SERVICE_UNAVAILABLE;
}
return r;
}
response.append((char)0); /* NULL terminate response */
if (outbl) {
*outbl = std::move(response);
}
return status;
}
class RGWRESTStreamOutCB : public RGWGetDataCB {
RGWRESTStreamS3PutObj *req;
public:
explicit RGWRESTStreamOutCB(RGWRESTStreamS3PutObj *_req) : req(_req) {}
int handle_data(bufferlist& bl, off_t bl_ofs, off_t bl_len) override; /* callback for object iteration when sending data */
};
int RGWRESTStreamOutCB::handle_data(bufferlist& bl, off_t bl_ofs, off_t bl_len)
{
dout(20) << "RGWRESTStreamOutCB::handle_data bl.length()=" << bl.length() << " bl_ofs=" << bl_ofs << " bl_len=" << bl_len << dendl;
if (!bl_ofs && bl_len == bl.length()) {
req->add_send_data(bl);
return 0;
}
bufferptr bp(bl.c_str() + bl_ofs, bl_len);
bufferlist new_bl;
new_bl.push_back(bp);
req->add_send_data(new_bl);
return 0;
}
RGWRESTStreamS3PutObj::~RGWRESTStreamS3PutObj()
{
delete out_cb;
}
static void grants_by_type_add_one_grant(map<int, string>& grants_by_type, int perm, ACLGrant& grant)
{
string& s = grants_by_type[perm];
if (!s.empty())
s.append(", ");
string id_type_str;
ACLGranteeType& type = grant.get_type();
switch (type.get_type()) {
case ACL_TYPE_GROUP:
id_type_str = "uri";
break;
case ACL_TYPE_EMAIL_USER:
id_type_str = "emailAddress";
break;
default:
id_type_str = "id";
}
rgw_user id;
grant.get_id(id);
s.append(id_type_str + "=\"" + id.to_str() + "\"");
}
struct grant_type_to_header {
int type;
const char *header;
};
struct grant_type_to_header grants_headers_def[] = {
{ RGW_PERM_FULL_CONTROL, "x-amz-grant-full-control"},
{ RGW_PERM_READ, "x-amz-grant-read"},
{ RGW_PERM_WRITE, "x-amz-grant-write"},
{ RGW_PERM_READ_ACP, "x-amz-grant-read-acp"},
{ RGW_PERM_WRITE_ACP, "x-amz-grant-write-acp"},
{ 0, NULL}
};
static bool grants_by_type_check_perm(map<int, string>& grants_by_type, int perm, ACLGrant& grant, int check_perm)
{
if ((perm & check_perm) == check_perm) {
grants_by_type_add_one_grant(grants_by_type, check_perm, grant);
return true;
}
return false;
}
static void grants_by_type_add_perm(map<int, string>& grants_by_type, int perm, ACLGrant& grant)
{
struct grant_type_to_header *t;
for (t = grants_headers_def; t->header; t++) {
if (grants_by_type_check_perm(grants_by_type, perm, grant, t->type))
return;
}
}
static void add_grants_headers(map<int, string>& grants, RGWEnv& env, meta_map_t& meta_map)
{
struct grant_type_to_header *t;
for (t = grants_headers_def; t->header; t++) {
map<int, string>::iterator iter = grants.find(t->type);
if (iter != grants.end()) {
env.set(t->header,iter->second);
meta_map[t->header] = iter->second;
}
}
}
RGWRESTGenerateHTTPHeaders::RGWRESTGenerateHTTPHeaders(CephContext *_cct, RGWEnv *_env, req_info *_info) :
DoutPrefix(_cct, dout_subsys, "rest gen http headers: "),
cct(_cct),
new_env(_env),
new_info(_info) {
}
void RGWRESTGenerateHTTPHeaders::init(const string& _method, const string& host,
const string& resource_prefix, const string& _url,
const string& resource, const param_vec_t& params,
std::optional<string> api_name)
{
scope_from_api_name(this, cct, host, api_name, ®ion, service);
string params_str;
map<string, string>& args = new_info->args.get_params();
do_get_params_str(params, args, params_str);
/* merge params with extra args so that we can sign correctly */
for (auto iter = params.begin(); iter != params.end(); ++iter) {
new_info->args.append(iter->first, iter->second);
}
url = _url + resource + params_str;
string date_str;
get_gmt_date_str(date_str);
new_env->set("HTTP_DATE", date_str.c_str());
new_env->set("HTTP_HOST", host);
method = _method;
new_info->method = method.c_str();
new_info->host = host;
new_info->script_uri = "/";
new_info->script_uri.append(resource_prefix);
new_info->script_uri.append(resource);
new_info->request_uri = new_info->script_uri;
}
static bool is_x_amz(const string& s) {
return boost::algorithm::starts_with(s, "x-amz-");
}
void RGWRESTGenerateHTTPHeaders::set_extra_headers(const map<string, string>& extra_headers)
{
for (auto iter : extra_headers) {
const string& name = lowercase_dash_http_attr(iter.first);
new_env->set(name, iter.second.c_str());
if (is_x_amz(name)) {
new_info->x_meta_map[name] = iter.second;
}
}
}
int RGWRESTGenerateHTTPHeaders::set_obj_attrs(const DoutPrefixProvider *dpp, map<string, bufferlist>& rgw_attrs)
{
map<string, string> new_attrs;
/* merge send headers */
for (auto& attr: rgw_attrs) {
bufferlist& bl = attr.second;
const string& name = attr.first;
string val = bl.c_str();
if (name.compare(0, sizeof(RGW_ATTR_META_PREFIX) - 1, RGW_ATTR_META_PREFIX) == 0) {
string header_name = RGW_AMZ_META_PREFIX;
header_name.append(name.substr(sizeof(RGW_ATTR_META_PREFIX) - 1));
new_attrs[header_name] = val;
}
}
RGWAccessControlPolicy policy;
int ret = rgw_policy_from_attrset(dpp, cct, rgw_attrs, &policy);
if (ret < 0) {
ldpp_dout(dpp, 0) << "ERROR: couldn't get policy ret=" << ret << dendl;
return ret;
}
set_http_attrs(new_attrs);
set_policy(policy);
return 0;
}
void RGWRESTGenerateHTTPHeaders::set_http_attrs(const map<string, string>& http_attrs)
{
/* merge send headers */
for (auto& attr: http_attrs) {
const string& val = attr.second;
const string& name = lowercase_dash_http_attr(attr.first);
if (is_x_amz(name)) {
new_env->set(name, val);
new_info->x_meta_map[name] = val;
} else {
new_env->set(attr.first, val); /* Ugh, using the uppercase representation,
as the signing function calls info.env.get("CONTENT_TYPE").
This needs to be cleaned up! */
}
}
}
void RGWRESTGenerateHTTPHeaders::set_policy(RGWAccessControlPolicy& policy)
{
/* update acl headers */
RGWAccessControlList& acl = policy.get_acl();
multimap<string, ACLGrant>& grant_map = acl.get_grant_map();
multimap<string, ACLGrant>::iterator giter;
map<int, string> grants_by_type;
for (giter = grant_map.begin(); giter != grant_map.end(); ++giter) {
ACLGrant& grant = giter->second;
ACLPermission& perm = grant.get_permission();
grants_by_type_add_perm(grants_by_type, perm.get_permissions(), grant);
}
add_grants_headers(grants_by_type, *new_env, new_info->x_meta_map);
}
int RGWRESTGenerateHTTPHeaders::sign(const DoutPrefixProvider *dpp, RGWAccessKey& key, const bufferlist *opt_content)
{
int ret = sign_request(dpp, key, region, service, *new_env, *new_info, opt_content);
if (ret < 0) {
ldpp_dout(dpp, 0) << "ERROR: failed to sign request" << dendl;
return ret;
}
return 0;
}
void RGWRESTStreamS3PutObj::send_init(const rgw_obj& obj)
{
string resource_str;
string resource;
string new_url = url;
string new_host = host;
const auto& bucket_name = obj.bucket.name;
if (host_style == VirtualStyle) {
resource_str = obj.get_oid();
new_url = bucket_name + "." + new_url;
new_host = bucket_name + "." + new_host;
} else {
resource_str = bucket_name + "/" + obj.get_oid();
}
//do not encode slash in object key name
url_encode(resource_str, resource, false);
if (new_url[new_url.size() - 1] != '/')
new_url.append("/");
method = "PUT";
headers_gen.init(method, new_host, resource_prefix, new_url, resource, params, api_name);
url = headers_gen.get_url();
}
void RGWRESTStreamS3PutObj::send_ready(const DoutPrefixProvider *dpp, RGWAccessKey& key, map<string, bufferlist>& rgw_attrs)
{
headers_gen.set_obj_attrs(dpp, rgw_attrs);
send_ready(dpp, key);
}
void RGWRESTStreamS3PutObj::send_ready(const DoutPrefixProvider *dpp, RGWAccessKey& key, const map<string, string>& http_attrs,
RGWAccessControlPolicy& policy)
{
headers_gen.set_http_attrs(http_attrs);
headers_gen.set_policy(policy);
send_ready(dpp, key);
}
void RGWRESTStreamS3PutObj::send_ready(const DoutPrefixProvider *dpp, RGWAccessKey& key)
{
headers_gen.sign(dpp, key, nullptr);
for (const auto& kv: new_env.get_map()) {
headers.emplace_back(kv);
}
out_cb = new RGWRESTStreamOutCB(this);
}
void RGWRESTStreamS3PutObj::put_obj_init(const DoutPrefixProvider *dpp, RGWAccessKey& key, const rgw_obj& obj, map<string, bufferlist>& attrs)
{
send_init(obj);
send_ready(dpp, key, attrs);
}
void set_str_from_headers(map<string, string>& out_headers, const string& header_name, string& str)
{
map<string, string>::iterator iter = out_headers.find(header_name);
if (iter != out_headers.end()) {
str = iter->second;
} else {
str.clear();
}
}
static int parse_rgwx_mtime(const DoutPrefixProvider *dpp, CephContext *cct, const string& s, ceph::real_time *rt)
{
string err;
vector<string> vec;
get_str_vec(s, ".", vec);
if (vec.empty()) {
return -EINVAL;
}
long secs = strict_strtol(vec[0].c_str(), 10, &err);
long nsecs = 0;
if (!err.empty()) {
ldpp_dout(dpp, 0) << "ERROR: failed converting mtime (" << s << ") to real_time " << dendl;
return -EINVAL;
}
if (vec.size() > 1) {
nsecs = strict_strtol(vec[1].c_str(), 10, &err);
if (!err.empty()) {
ldpp_dout(dpp, 0) << "ERROR: failed converting mtime (" << s << ") to real_time " << dendl;
return -EINVAL;
}
}
*rt = utime_t(secs, nsecs).to_real_time();
return 0;
}
static void send_prepare_convert(const rgw_obj& obj, string *resource)
{
string urlsafe_bucket, urlsafe_object;
url_encode(obj.bucket.get_key(':', 0), urlsafe_bucket);
url_encode(obj.key.name, urlsafe_object);
*resource = urlsafe_bucket + "/" + urlsafe_object;
}
int RGWRESTStreamRWRequest::send_request(const DoutPrefixProvider *dpp, RGWAccessKey& key, map<string, string>& extra_headers, const rgw_obj& obj, RGWHTTPManager *mgr)
{
string resource;
send_prepare_convert(obj, &resource);
return send_request(dpp, &key, extra_headers, resource, mgr);
}
int RGWRESTStreamRWRequest::send_prepare(const DoutPrefixProvider *dpp, RGWAccessKey& key, map<string, string>& extra_headers, const rgw_obj& obj)
{
string resource;
send_prepare_convert(obj, &resource);
return do_send_prepare(dpp, &key, extra_headers, resource);
}
int RGWRESTStreamRWRequest::send_prepare(const DoutPrefixProvider *dpp, RGWAccessKey *key, map<string, string>& extra_headers, const string& resource,
bufferlist *send_data)
{
string new_resource;
//do not encode slash
url_encode(resource, new_resource, false);
return do_send_prepare(dpp, key, extra_headers, new_resource, send_data);
}
int RGWRESTStreamRWRequest::do_send_prepare(const DoutPrefixProvider *dpp, RGWAccessKey *key, map<string, string>& extra_headers, const string& resource,
bufferlist *send_data)
{
string new_url = url;
if (!new_url.empty() && new_url.back() != '/')
new_url.append("/");
string new_resource;
string bucket_name;
string old_resource = resource;
if (resource[0] == '/') {
new_resource = resource.substr(1);
} else {
new_resource = resource;
}
size_t pos = new_resource.find("/");
bucket_name = new_resource.substr(0, pos);
//when dest is a bucket with out other params, uri should end up with '/'
if(pos == string::npos && params.size() == 0 && host_style == VirtualStyle) {
new_resource.append("/");
}
if (host_style == VirtualStyle) {
new_url = protocol + "://" + bucket_name + "." + host;
if(pos == string::npos) {
new_resource = "";
} else {
new_resource = new_resource.substr(pos+1);
}
}
headers_gen.emplace(cct, &new_env, &new_info);
headers_gen->init(method, host, resource_prefix, new_url, new_resource, params, api_name);
headers_gen->set_http_attrs(extra_headers);
if (key) {
sign_key = *key;
}
if (send_data) {
set_send_length(send_data->length());
set_outbl(*send_data);
set_send_data_hint(true);
}
method = new_info.method;
url = headers_gen->get_url();
return 0;
}
int RGWRESTStreamRWRequest::send_request(const DoutPrefixProvider *dpp, RGWAccessKey *key, map<string, string>& extra_headers, const string& resource,
RGWHTTPManager *mgr, bufferlist *send_data)
{
int ret = send_prepare(dpp, key, extra_headers, resource, send_data);
if (ret < 0) {
return ret;
}
return send(mgr);
}
int RGWRESTStreamRWRequest::send(RGWHTTPManager *mgr)
{
if (!headers_gen) {
ldpp_dout(this, 0) << "ERROR: " << __func__ << "(): send_prepare() was not called: likey a bug!" << dendl;
return -EINVAL;
}
const bufferlist *outblp{nullptr};
if (send_len == outbl.length()) {
outblp = &outbl;
}
if (sign_key) {
int r = headers_gen->sign(this, *sign_key, outblp);
if (r < 0) {
ldpp_dout(this, 0) << "ERROR: failed to sign request" << dendl;
return r;
}
}
for (const auto& kv: new_env.get_map()) {
headers.emplace_back(kv);
}
return RGWHTTPStreamRWRequest::send(mgr);
}
int RGWHTTPStreamRWRequest::complete_request(optional_yield y,
string *etag,
real_time *mtime,
uint64_t *psize,
map<string, string> *pattrs,
map<string, string> *pheaders)
{
int ret = wait(y);
if (ret < 0) {
return ret;
}
unique_lock guard(out_headers_lock);
if (etag) {
set_str_from_headers(out_headers, "ETAG", *etag);
}
if (status >= 0) {
if (mtime) {
string mtime_str;
set_str_from_headers(out_headers, "RGWX_MTIME", mtime_str);
if (!mtime_str.empty()) {
int ret = parse_rgwx_mtime(this, cct, mtime_str, mtime);
if (ret < 0) {
return ret;
}
} else {
*mtime = real_time();
}
}
if (psize) {
string size_str;
set_str_from_headers(out_headers, "RGWX_OBJECT_SIZE", size_str);
string err;
*psize = strict_strtoll(size_str.c_str(), 10, &err);
if (!err.empty()) {
ldpp_dout(this, 0) << "ERROR: failed parsing embedded metadata object size (" << size_str << ") to int " << dendl;
return -EIO;
}
}
}
for (auto iter = out_headers.begin(); pattrs && iter != out_headers.end(); ++iter) {
const string& attr_name = iter->first;
if (attr_name.compare(0, sizeof(RGW_HTTP_RGWX_ATTR_PREFIX) - 1, RGW_HTTP_RGWX_ATTR_PREFIX) == 0) {
string name = attr_name.substr(sizeof(RGW_HTTP_RGWX_ATTR_PREFIX) - 1);
const char *src = name.c_str();
char buf[name.size() + 1];
char *dest = buf;
for (; *src; ++src, ++dest) {
switch(*src) {
case '_':
*dest = '-';
break;
default:
*dest = tolower(*src);
}
}
*dest = '\0';
(*pattrs)[buf] = iter->second;
}
}
if (pheaders) {
*pheaders = std::move(out_headers);
}
return status;
}
int RGWHTTPStreamRWRequest::handle_header(const string& name, const string& val)
{
if (name == "RGWX_EMBEDDED_METADATA_LEN") {
string err;
long len = strict_strtol(val.c_str(), 10, &err);
if (!err.empty()) {
ldpp_dout(this, 0) << "ERROR: failed converting embedded metadata len (" << val << ") to int " << dendl;
return -EINVAL;
}
cb->set_extra_data_len(len);
}
return 0;
}
int RGWHTTPStreamRWRequest::receive_data(void *ptr, size_t len, bool *pause)
{
size_t orig_len = len;
if (cb) {
in_data.append((const char *)ptr, len);
size_t orig_in_data_len = in_data.length();
int ret = cb->handle_data(in_data, pause);
if (ret < 0)
return ret;
if (ret == 0) {
in_data.clear();
} else {
/* partial read */
ceph_assert(in_data.length() <= orig_in_data_len);
len = ret;
bufferlist bl;
size_t left_to_read = orig_in_data_len - len;
if (in_data.length() > left_to_read) {
in_data.splice(0, in_data.length() - left_to_read, &bl);
}
}
}
ofs += len;
return orig_len;
}
void RGWHTTPStreamRWRequest::set_stream_write(bool s) {
std::lock_guard wl{write_lock};
stream_writes = s;
}
void RGWHTTPStreamRWRequest::unpause_receive()
{
std::lock_guard req_locker{get_req_lock()};
if (!read_paused) {
_set_read_paused(false);
}
}
void RGWHTTPStreamRWRequest::add_send_data(bufferlist& bl)
{
std::scoped_lock locker{get_req_lock(), write_lock};
outbl.claim_append(bl);
_set_write_paused(false);
}
uint64_t RGWHTTPStreamRWRequest::get_pending_send_size()
{
std::lock_guard wl{write_lock};
return outbl.length();
}
void RGWHTTPStreamRWRequest::finish_write()
{
std::scoped_lock locker{get_req_lock(), write_lock};
write_stream_complete = true;
_set_write_paused(false);
}
int RGWHTTPStreamRWRequest::send_data(void *ptr, size_t len, bool *pause)
{
uint64_t out_len;
uint64_t send_size;
{
std::lock_guard wl{write_lock};
if (outbl.length() == 0) {
if ((stream_writes && !write_stream_complete) ||
(write_ofs < send_len)) {
*pause = true;
}
return 0;
}
len = std::min(len, (size_t)outbl.length());
bufferlist bl;
outbl.splice(0, len, &bl);
send_size = bl.length();
if (send_size > 0) {
memcpy(ptr, bl.c_str(), send_size);
write_ofs += send_size;
}
out_len = outbl.length();
}
/* don't need to be under write_lock here, avoid deadlocks in case notify callback
* needs to lock */
if (write_drain_cb) {
write_drain_cb->notify(out_len);
}
return send_size;
}
int RGWHTTPStreamRWRequest::send(RGWHTTPManager *mgr)
{
if (!mgr) {
return RGWHTTP::send(this);
}
int r = mgr->add_request(this);
if (r < 0)
return r;
return 0;
}
| 30,784 | 26.364444 | 210 |
cc
|
null |
ceph-main/src/rgw/rgw_rest_client.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#pragma once
#include "rgw_http_client.h"
class RGWGetDataCB;
class RGWHTTPSimpleRequest : public RGWHTTPClient {
protected:
int http_status;
int status;
using unique_lock = std::unique_lock<std::mutex>;
std::mutex out_headers_lock;
std::map<std::string, std::string> out_headers;
param_vec_t params;
bufferlist::iterator *send_iter;
size_t max_response; /* we need this as we don't stream out response */
bufferlist response;
virtual int handle_header(const std::string& name, const std::string& val);
void get_params_str(std::map<std::string, std::string>& extra_args, std::string& dest);
public:
RGWHTTPSimpleRequest(CephContext *_cct, const std::string& _method, const std::string& _url,
param_vec_t *_headers, param_vec_t *_params) : RGWHTTPClient(_cct, _method, _url),
http_status(0), status(0),
send_iter(NULL),
max_response(0) {
set_headers(_headers);
set_params(_params);
}
void set_headers(param_vec_t *_headers) {
if (_headers)
headers = *_headers;
}
void set_params(param_vec_t *_params) {
if (_params)
params = *_params;
}
int receive_header(void *ptr, size_t len) override;
int receive_data(void *ptr, size_t len, bool *pause) override;
int send_data(void *ptr, size_t len, bool* pause=nullptr) override;
bufferlist& get_response() { return response; }
void get_out_headers(std::map<std::string, std::string> *pheaders); /* modifies out_headers */
int get_http_status() { return http_status; }
int get_status();
};
class RGWRESTSimpleRequest : public RGWHTTPSimpleRequest {
std::optional<std::string> api_name;
public:
RGWRESTSimpleRequest(CephContext *_cct, const std::string& _method, const std::string& _url,
param_vec_t *_headers, param_vec_t *_params,
std::optional<std::string> _api_name) : RGWHTTPSimpleRequest(_cct, _method, _url, _headers, _params), api_name(_api_name) {}
int forward_request(const DoutPrefixProvider *dpp, const RGWAccessKey& key, req_info& info, size_t max_response, bufferlist *inbl, bufferlist *outbl, optional_yield y, std::string service="");
};
class RGWWriteDrainCB {
public:
RGWWriteDrainCB() = default;
virtual ~RGWWriteDrainCB() = default;
virtual void notify(uint64_t pending_size) = 0;
};
class RGWRESTGenerateHTTPHeaders : public DoutPrefix {
CephContext *cct;
RGWEnv *new_env;
req_info *new_info;
std::string region;
std::string service;
std::string method;
std::string url;
std::string resource;
public:
RGWRESTGenerateHTTPHeaders(CephContext *_cct, RGWEnv *_env, req_info *_info);
void init(const std::string& method, const std::string& host,
const std::string& resource_prefix, const std::string& url,
const std::string& resource, const param_vec_t& params,
std::optional<std::string> api_name);
void set_extra_headers(const std::map<std::string, std::string>& extra_headers);
int set_obj_attrs(const DoutPrefixProvider *dpp, std::map<std::string, bufferlist>& rgw_attrs);
void set_http_attrs(const std::map<std::string, std::string>& http_attrs);
void set_policy(RGWAccessControlPolicy& policy);
int sign(const DoutPrefixProvider *dpp, RGWAccessKey& key, const bufferlist *opt_content);
const std::string& get_url() { return url; }
};
class RGWHTTPStreamRWRequest : public RGWHTTPSimpleRequest {
public:
class ReceiveCB;
private:
ceph::mutex lock =
ceph::make_mutex("RGWHTTPStreamRWRequest");
ceph::mutex write_lock =
ceph::make_mutex("RGWHTTPStreamRWRequest::write_lock");
ReceiveCB *cb{nullptr};
RGWWriteDrainCB *write_drain_cb{nullptr};
bufferlist in_data;
size_t chunk_ofs{0};
size_t ofs{0};
uint64_t write_ofs{0};
bool read_paused{false};
bool send_paused{false};
bool stream_writes{false};
bool write_stream_complete{false};
protected:
bufferlist outbl;
int handle_header(const std::string& name, const std::string& val) override;
public:
int send_data(void *ptr, size_t len, bool *pause) override;
int receive_data(void *ptr, size_t len, bool *pause) override;
class ReceiveCB {
protected:
uint64_t extra_data_len{0};
public:
ReceiveCB() = default;
virtual ~ReceiveCB() = default;
virtual int handle_data(bufferlist& bl, bool *pause = nullptr) = 0;
virtual void set_extra_data_len(uint64_t len) {
extra_data_len = len;
}
};
RGWHTTPStreamRWRequest(CephContext *_cct, const std::string& _method, const std::string& _url,
param_vec_t *_headers, param_vec_t *_params) : RGWHTTPSimpleRequest(_cct, _method, _url, _headers, _params) {
}
RGWHTTPStreamRWRequest(CephContext *_cct, const std::string& _method, const std::string& _url, ReceiveCB *_cb,
param_vec_t *_headers, param_vec_t *_params) : RGWHTTPSimpleRequest(_cct, _method, _url, _headers, _params),
cb(_cb) {
}
virtual ~RGWHTTPStreamRWRequest() override {}
void set_outbl(bufferlist& _outbl) {
outbl.swap(_outbl);
}
void set_in_cb(ReceiveCB *_cb) { cb = _cb; }
void set_write_drain_cb(RGWWriteDrainCB *_cb) { write_drain_cb = _cb; }
void unpause_receive();
void add_send_data(bufferlist& bl);
void set_stream_write(bool s);
uint64_t get_pending_send_size();
/* finish streaming writes */
void finish_write();
virtual int send(RGWHTTPManager *mgr);
int complete_request(optional_yield y,
std::string *etag = nullptr,
real_time *mtime = nullptr,
uint64_t *psize = nullptr,
std::map<std::string, std::string> *pattrs = nullptr,
std::map<std::string, std::string> *pheaders = nullptr);
};
class RGWRESTStreamRWRequest : public RGWHTTPStreamRWRequest {
std::optional<RGWAccessKey> sign_key;
std::optional<RGWRESTGenerateHTTPHeaders> headers_gen;
RGWEnv new_env;
req_info new_info;
protected:
std::optional<std::string> api_name;
HostStyle host_style;
public:
RGWRESTStreamRWRequest(CephContext *_cct, const std::string& _method, const std::string& _url, RGWHTTPStreamRWRequest::ReceiveCB *_cb,
param_vec_t *_headers, param_vec_t *_params,
std::optional<std::string> _api_name, HostStyle _host_style = PathStyle) :
RGWHTTPStreamRWRequest(_cct, _method, _url, _cb, _headers, _params),
new_info(_cct, &new_env),
api_name(_api_name), host_style(_host_style) {
}
virtual ~RGWRESTStreamRWRequest() override {}
int send_prepare(const DoutPrefixProvider *dpp, RGWAccessKey *key, std::map<std::string, std::string>& extra_headers, const std::string& resource, bufferlist *send_data = nullptr /* optional input data */);
int send_prepare(const DoutPrefixProvider *dpp, RGWAccessKey& key, std::map<std::string, std::string>& extra_headers, const rgw_obj& obj);
int send(RGWHTTPManager *mgr) override;
int send_request(const DoutPrefixProvider *dpp, RGWAccessKey& key, std::map<std::string, std::string>& extra_headers, const rgw_obj& obj, RGWHTTPManager *mgr);
int send_request(const DoutPrefixProvider *dpp, RGWAccessKey *key, std::map<std::string, std::string>& extra_headers, const std::string& resource, RGWHTTPManager *mgr, bufferlist *send_data = nullptr /* optional input data */);
void add_params(param_vec_t *params);
private:
int do_send_prepare(const DoutPrefixProvider *dpp, RGWAccessKey *key, std::map<std::string, std::string>& extra_headers, const std::string& resource, bufferlist *send_data = nullptr /* optional input data */);
};
class RGWRESTStreamReadRequest : public RGWRESTStreamRWRequest {
public:
RGWRESTStreamReadRequest(CephContext *_cct, const std::string& _url, ReceiveCB *_cb, param_vec_t *_headers,
param_vec_t *_params, std::optional<std::string> _api_name,
HostStyle _host_style = PathStyle) : RGWRESTStreamRWRequest(_cct, "GET", _url, _cb, _headers, _params, _api_name, _host_style) {}
};
class RGWRESTStreamHeadRequest : public RGWRESTStreamRWRequest {
public:
RGWRESTStreamHeadRequest(CephContext *_cct, const std::string& _url, ReceiveCB *_cb, param_vec_t *_headers,
param_vec_t *_params, std::optional<std::string> _api_name) : RGWRESTStreamRWRequest(_cct, "HEAD", _url, _cb, _headers, _params, _api_name) {}
};
class RGWRESTStreamSendRequest : public RGWRESTStreamRWRequest {
public:
RGWRESTStreamSendRequest(CephContext *_cct, const std::string& method,
const std::string& _url,
ReceiveCB *_cb, param_vec_t *_headers, param_vec_t *_params,
std::optional<std::string> _api_name,
HostStyle _host_style = PathStyle) : RGWRESTStreamRWRequest(_cct, method, _url, _cb, _headers, _params, _api_name, _host_style) {}
};
class RGWRESTStreamS3PutObj : public RGWHTTPStreamRWRequest {
std::optional<std::string> api_name;
HostStyle host_style;
RGWGetDataCB *out_cb;
RGWEnv new_env;
req_info new_info;
RGWRESTGenerateHTTPHeaders headers_gen;
public:
RGWRESTStreamS3PutObj(CephContext *_cct, const std::string& _method, const std::string& _url, param_vec_t *_headers,
param_vec_t *_params, std::optional<std::string> _api_name,
HostStyle _host_style) : RGWHTTPStreamRWRequest(_cct, _method, _url, nullptr, _headers, _params),
api_name(_api_name), host_style(_host_style),
out_cb(NULL), new_info(cct, &new_env), headers_gen(_cct, &new_env, &new_info) {}
~RGWRESTStreamS3PutObj() override;
void send_init(const rgw_obj& obj);
void send_ready(const DoutPrefixProvider *dpp, RGWAccessKey& key, std::map<std::string, bufferlist>& rgw_attrs);
void send_ready(const DoutPrefixProvider *dpp, RGWAccessKey& key, const std::map<std::string, std::string>& http_attrs,
RGWAccessControlPolicy& policy);
void send_ready(const DoutPrefixProvider *dpp, RGWAccessKey& key);
void put_obj_init(const DoutPrefixProvider *dpp, RGWAccessKey& key, const rgw_obj& obj, std::map<std::string, bufferlist>& attrs);
RGWGetDataCB *get_out_cb() { return out_cb; }
};
| 10,392 | 39.282946 | 229 |
h
|
null |
ceph-main/src/rgw/rgw_rest_config.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2013 eNovance SAS <[email protected]>
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "common/ceph_json.h"
#include "common/strtol.h"
#include "rgw_rest.h"
#include "rgw_op.h"
#include "rgw_rados.h"
#include "rgw_rest_s3.h"
#include "rgw_rest_config.h"
#include "rgw_client_io.h"
#include "rgw_sal_rados.h"
#include "common/errno.h"
#include "include/ceph_assert.h"
#include "services/svc_zone.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rgw
using namespace std;
void RGWOp_ZoneConfig_Get::send_response() {
const RGWZoneParams& zone_params = static_cast<rgw::sal::RadosStore*>(driver)->svc()->zone->get_zone_params();
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s);
if (op_ret < 0)
return;
encode_json("zone_params", zone_params, s->formatter);
flusher.flush();
}
RGWOp* RGWHandler_Config::op_get() {
bool exists;
string type = s->info.args.get("type", &exists);
if (type.compare("zone") == 0) {
return new RGWOp_ZoneConfig_Get();
}
return nullptr;
}
| 1,392 | 23.017241 | 112 |
cc
|
null |
ceph-main/src/rgw/rgw_rest_config.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2013 eNovance SAS <[email protected]>
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#pragma once
#include "rgw_auth_s3.h"
#include "rgw_rest.h"
#include "rgw_zone.h"
class RGWOp_ZoneConfig_Get : public RGWRESTOp {
RGWZoneParams zone_params;
public:
RGWOp_ZoneConfig_Get() {}
int check_caps(const RGWUserCaps& caps) override {
return caps.check_cap("zone", RGW_CAP_READ);
}
int verify_permission(optional_yield) override {
return check_caps(s->user->get_caps());
}
void execute(optional_yield) override {} /* driver already has the info we need, just need to send response */
void send_response() override ;
const char* name() const override {
return "get_zone_config";
}
};
class RGWHandler_Config : public RGWHandler_Auth_S3 {
protected:
RGWOp *op_get() override;
int read_permissions(RGWOp*, optional_yield) override {
return 0;
}
public:
using RGWHandler_Auth_S3::RGWHandler_Auth_S3;
~RGWHandler_Config() override = default;
};
class RGWRESTMgr_Config : public RGWRESTMgr {
public:
RGWRESTMgr_Config() = default;
~RGWRESTMgr_Config() override = default;
RGWHandler_REST* get_handler(rgw::sal::Driver* ,
req_state*,
const rgw::auth::StrategyRegistry& auth_registry,
const std::string&) override {
return new RGWHandler_Config(auth_registry);
}
};
| 1,739 | 25.769231 | 112 |
h
|
null |
ceph-main/src/rgw/rgw_rest_conn.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#include "rgw_zone.h"
#include "rgw_rest_conn.h"
#include "rgw_sal.h"
#include "rgw_rados.h"
#define dout_subsys ceph_subsys_rgw
using namespace std;
RGWRESTConn::RGWRESTConn(CephContext *_cct, rgw::sal::Driver* driver,
const string& _remote_id,
const list<string>& remote_endpoints,
std::optional<string> _api_name,
HostStyle _host_style)
: cct(_cct),
endpoints(remote_endpoints.begin(), remote_endpoints.end()),
remote_id(_remote_id),
api_name(_api_name),
host_style(_host_style)
{
if (driver) {
key = driver->get_zone()->get_system_key();
self_zone_group = driver->get_zone()->get_zonegroup().get_id();
}
}
RGWRESTConn::RGWRESTConn(CephContext *_cct,
const string& _remote_id,
const list<string>& remote_endpoints,
RGWAccessKey _cred,
std::string _zone_group,
std::optional<string> _api_name,
HostStyle _host_style)
: cct(_cct),
endpoints(remote_endpoints.begin(), remote_endpoints.end()),
key(_cred),
self_zone_group(_zone_group),
remote_id(_remote_id),
api_name(_api_name),
host_style(_host_style)
{
}
RGWRESTConn::RGWRESTConn(RGWRESTConn&& other)
: cct(other.cct),
endpoints(std::move(other.endpoints)),
key(std::move(other.key)),
self_zone_group(std::move(other.self_zone_group)),
remote_id(std::move(other.remote_id)),
counter(other.counter.load())
{
}
RGWRESTConn& RGWRESTConn::operator=(RGWRESTConn&& other)
{
cct = other.cct;
endpoints = std::move(other.endpoints);
key = std::move(other.key);
self_zone_group = std::move(other.self_zone_group);
remote_id = std::move(other.remote_id);
counter = other.counter.load();
return *this;
}
int RGWRESTConn::get_url(string& endpoint)
{
if (endpoints.empty()) {
ldout(cct, 0) << "ERROR: endpoints not configured for upstream zone" << dendl;
return -EIO;
}
int i = ++counter;
endpoint = endpoints[i % endpoints.size()];
return 0;
}
string RGWRESTConn::get_url()
{
string endpoint;
get_url(endpoint);
return endpoint;
}
void RGWRESTConn::populate_params(param_vec_t& params, const rgw_user *uid, const string& zonegroup)
{
populate_uid(params, uid);
populate_zonegroup(params, zonegroup);
}
int RGWRESTConn::forward(const DoutPrefixProvider *dpp, const rgw_user& uid, req_info& info, obj_version *objv, size_t max_response, bufferlist *inbl, bufferlist *outbl, optional_yield y)
{
string url;
int ret = get_url(url);
if (ret < 0)
return ret;
param_vec_t params;
populate_params(params, &uid, self_zone_group);
if (objv) {
params.push_back(param_pair_t(RGW_SYS_PARAM_PREFIX "tag", objv->tag));
char buf[16];
snprintf(buf, sizeof(buf), "%lld", (long long)objv->ver);
params.push_back(param_pair_t(RGW_SYS_PARAM_PREFIX "ver", buf));
}
RGWRESTSimpleRequest req(cct, info.method, url, NULL, ¶ms, api_name);
return req.forward_request(dpp, key, info, max_response, inbl, outbl, y);
}
int RGWRESTConn::forward_iam_request(const DoutPrefixProvider *dpp, const RGWAccessKey& key, req_info& info, obj_version *objv, size_t max_response, bufferlist *inbl, bufferlist *outbl, optional_yield y)
{
string url;
int ret = get_url(url);
if (ret < 0)
return ret;
param_vec_t params;
if (objv) {
params.push_back(param_pair_t(RGW_SYS_PARAM_PREFIX "tag", objv->tag));
char buf[16];
snprintf(buf, sizeof(buf), "%lld", (long long)objv->ver);
params.push_back(param_pair_t(RGW_SYS_PARAM_PREFIX "ver", buf));
}
std::string service = "iam";
RGWRESTSimpleRequest req(cct, info.method, url, NULL, ¶ms, api_name);
return req.forward_request(dpp, key, info, max_response, inbl, outbl, y, service);
}
int RGWRESTConn::put_obj_send_init(const rgw_obj& obj, const rgw_http_param_pair *extra_params, RGWRESTStreamS3PutObj **req)
{
string url;
int ret = get_url(url);
if (ret < 0)
return ret;
rgw_user uid;
param_vec_t params;
populate_params(params, &uid, self_zone_group);
if (extra_params) {
append_param_list(params, extra_params);
}
RGWRESTStreamS3PutObj *wr = new RGWRESTStreamS3PutObj(cct, "PUT", url, NULL, ¶ms, api_name, host_style);
wr->send_init(obj);
*req = wr;
return 0;
}
int RGWRESTConn::put_obj_async_init(const DoutPrefixProvider *dpp, const rgw_user& uid, const rgw_obj& obj,
map<string, bufferlist>& attrs,
RGWRESTStreamS3PutObj **req)
{
string url;
int ret = get_url(url);
if (ret < 0)
return ret;
param_vec_t params;
populate_params(params, &uid, self_zone_group);
RGWRESTStreamS3PutObj *wr = new RGWRESTStreamS3PutObj(cct, "PUT", url, NULL, ¶ms, api_name, host_style);
wr->put_obj_init(dpp, key, obj, attrs);
*req = wr;
return 0;
}
int RGWRESTConn::complete_request(RGWRESTStreamS3PutObj *req, string& etag,
real_time *mtime, optional_yield y)
{
int ret = req->complete_request(y, &etag, mtime);
delete req;
return ret;
}
static void set_date_header(const real_time *t, map<string, string>& headers, bool high_precision_time, const string& header_name)
{
if (!t) {
return;
}
stringstream s;
utime_t tm = utime_t(*t);
if (high_precision_time) {
tm.gmtime_nsec(s);
} else {
tm.gmtime(s);
}
headers[header_name] = s.str();
}
template <class T>
static void set_header(T val, map<string, string>& headers, const string& header_name)
{
stringstream s;
s << val;
headers[header_name] = s.str();
}
int RGWRESTConn::get_obj(const DoutPrefixProvider *dpp, const rgw_user& uid, req_info *info /* optional */, const rgw_obj& obj,
const real_time *mod_ptr, const real_time *unmod_ptr,
uint32_t mod_zone_id, uint64_t mod_pg_ver,
bool prepend_metadata, bool get_op, bool rgwx_stat,
bool sync_manifest, bool skip_decrypt,
rgw_zone_set_entry *dst_zone_trace, bool sync_cloudtiered,
bool send, RGWHTTPStreamRWRequest::ReceiveCB *cb, RGWRESTStreamRWRequest **req)
{
get_obj_params params;
params.uid = uid;
params.info = info;
params.mod_ptr = mod_ptr;
params.mod_pg_ver = mod_pg_ver;
params.prepend_metadata = prepend_metadata;
params.get_op = get_op;
params.rgwx_stat = rgwx_stat;
params.sync_manifest = sync_manifest;
params.skip_decrypt = skip_decrypt;
params.sync_cloudtiered = sync_cloudtiered;
params.dst_zone_trace = dst_zone_trace;
params.cb = cb;
return get_obj(dpp, obj, params, send, req);
}
int RGWRESTConn::get_obj(const DoutPrefixProvider *dpp, const rgw_obj& obj, const get_obj_params& in_params, bool send, RGWRESTStreamRWRequest **req)
{
string url;
int ret = get_url(url);
if (ret < 0)
return ret;
param_vec_t params;
populate_params(params, &in_params.uid, self_zone_group);
if (in_params.prepend_metadata) {
params.push_back(param_pair_t(RGW_SYS_PARAM_PREFIX "prepend-metadata", "true"));
}
if (in_params.rgwx_stat) {
params.push_back(param_pair_t(RGW_SYS_PARAM_PREFIX "stat", "true"));
}
if (in_params.sync_manifest) {
params.push_back(param_pair_t(RGW_SYS_PARAM_PREFIX "sync-manifest", ""));
}
if (in_params.sync_cloudtiered) {
params.push_back(param_pair_t(RGW_SYS_PARAM_PREFIX "sync-cloudtiered", ""));
}
if (in_params.skip_decrypt) {
params.push_back(param_pair_t(RGW_SYS_PARAM_PREFIX "skip-decrypt", ""));
}
if (in_params.dst_zone_trace) {
params.push_back(param_pair_t(RGW_SYS_PARAM_PREFIX "if-not-replicated-to", in_params.dst_zone_trace->to_str()));
}
if (!obj.key.instance.empty()) {
params.push_back(param_pair_t("versionId", obj.key.instance));
}
if (in_params.get_op) {
*req = new RGWRESTStreamReadRequest(cct, url, in_params.cb, NULL, ¶ms, api_name, host_style);
} else {
*req = new RGWRESTStreamHeadRequest(cct, url, in_params.cb, NULL, ¶ms, api_name);
}
map<string, string> extra_headers;
if (in_params.info) {
const auto& orig_map = in_params.info->env->get_map();
/* add original headers that start with HTTP_X_AMZ_ */
static constexpr char SEARCH_AMZ_PREFIX[] = "HTTP_X_AMZ_";
for (auto iter= orig_map.lower_bound(SEARCH_AMZ_PREFIX); iter != orig_map.end(); ++iter) {
const string& name = iter->first;
if (name == "HTTP_X_AMZ_DATE") /* don't forward date from original request */
continue;
if (name.compare(0, strlen(SEARCH_AMZ_PREFIX), SEARCH_AMZ_PREFIX) != 0)
break;
extra_headers[iter->first] = iter->second;
}
}
set_date_header(in_params.mod_ptr, extra_headers, in_params.high_precision_time, "HTTP_IF_MODIFIED_SINCE");
set_date_header(in_params.unmod_ptr, extra_headers, in_params.high_precision_time, "HTTP_IF_UNMODIFIED_SINCE");
if (!in_params.etag.empty()) {
set_header(in_params.etag, extra_headers, "HTTP_IF_MATCH");
}
if (in_params.mod_zone_id != 0) {
set_header(in_params.mod_zone_id, extra_headers, "HTTP_DEST_ZONE_SHORT_ID");
}
if (in_params.mod_pg_ver != 0) {
set_header(in_params.mod_pg_ver, extra_headers, "HTTP_DEST_PG_VER");
}
if (in_params.range_is_set) {
char buf[64];
snprintf(buf, sizeof(buf), "bytes=%lld-%lld", (long long)in_params.range_start, (long long)in_params.range_end);
set_header(buf, extra_headers, "RANGE");
}
int r = (*req)->send_prepare(dpp, key, extra_headers, obj);
if (r < 0) {
goto done_err;
}
if (!send) {
return 0;
}
r = (*req)->send(nullptr);
if (r < 0) {
goto done_err;
}
return 0;
done_err:
delete *req;
*req = nullptr;
return r;
}
int RGWRESTConn::complete_request(RGWRESTStreamRWRequest *req,
string *etag,
real_time *mtime,
uint64_t *psize,
map<string, string> *pattrs,
map<string, string> *pheaders,
optional_yield y)
{
int ret = req->complete_request(y, etag, mtime, psize, pattrs, pheaders);
delete req;
return ret;
}
int RGWRESTConn::get_resource(const DoutPrefixProvider *dpp,
const string& resource,
param_vec_t *extra_params,
map<string, string> *extra_headers,
bufferlist& bl,
bufferlist *send_data,
RGWHTTPManager *mgr,
optional_yield y)
{
string url;
int ret = get_url(url);
if (ret < 0)
return ret;
param_vec_t params;
if (extra_params) {
params.insert(params.end(), extra_params->begin(), extra_params->end());
}
populate_params(params, nullptr, self_zone_group);
RGWStreamIntoBufferlist cb(bl);
RGWRESTStreamReadRequest req(cct, url, &cb, NULL, ¶ms, api_name, host_style);
map<string, string> headers;
if (extra_headers) {
headers.insert(extra_headers->begin(), extra_headers->end());
}
ret = req.send_request(dpp, &key, headers, resource, mgr, send_data);
if (ret < 0) {
ldpp_dout(dpp, 5) << __func__ << ": send_request() resource=" << resource << " returned ret=" << ret << dendl;
return ret;
}
return req.complete_request(y);
}
int RGWRESTConn::send_resource(const DoutPrefixProvider *dpp, const std::string& method,
const std::string& resource, rgw_http_param_pair *extra_params,
std::map<std::string, std::string> *extra_headers, bufferlist& bl,
bufferlist *send_data, RGWHTTPManager *mgr, optional_yield y)
{
std::string url;
int ret = get_url(url);
if (ret < 0)
return ret;
param_vec_t params;
if (extra_params) {
params = make_param_list(extra_params);
}
populate_params(params, nullptr, self_zone_group);
RGWStreamIntoBufferlist cb(bl);
RGWRESTStreamSendRequest req(cct, method, url, &cb, NULL, ¶ms, api_name, host_style);
std::map<std::string, std::string> headers;
if (extra_headers) {
headers.insert(extra_headers->begin(), extra_headers->end());
}
ret = req.send_request(dpp, &key, headers, resource, mgr, send_data);
if (ret < 0) {
ldpp_dout(dpp, 5) << __func__ << ": send_request() resource=" << resource << " returned ret=" << ret << dendl;
return ret;
}
ret = req.complete_request(y);
if (ret < 0) {
ldpp_dout(dpp, 5) << __func__ << ": complete_request() resource=" << resource << " returned ret=" << ret << dendl;
}
return ret;
}
RGWRESTReadResource::RGWRESTReadResource(RGWRESTConn *_conn,
const string& _resource,
const rgw_http_param_pair *pp,
param_vec_t *extra_headers,
RGWHTTPManager *_mgr)
: cct(_conn->get_ctx()), conn(_conn), resource(_resource),
params(make_param_list(pp)), cb(bl), mgr(_mgr),
req(cct, conn->get_url(), &cb, NULL, NULL, _conn->get_api_name())
{
init_common(extra_headers);
}
RGWRESTReadResource::RGWRESTReadResource(RGWRESTConn *_conn,
const string& _resource,
param_vec_t& _params,
param_vec_t *extra_headers,
RGWHTTPManager *_mgr)
: cct(_conn->get_ctx()), conn(_conn), resource(_resource), params(_params),
cb(bl), mgr(_mgr), req(cct, conn->get_url(), &cb, NULL, NULL, _conn->get_api_name())
{
init_common(extra_headers);
}
void RGWRESTReadResource::init_common(param_vec_t *extra_headers)
{
conn->populate_params(params, nullptr, conn->get_self_zonegroup());
if (extra_headers) {
headers.insert(extra_headers->begin(), extra_headers->end());
}
req.set_params(¶ms);
}
int RGWRESTReadResource::read(const DoutPrefixProvider *dpp, optional_yield y)
{
int ret = req.send_request(dpp, &conn->get_key(), headers, resource, mgr);
if (ret < 0) {
ldpp_dout(dpp, 5) << __func__ << ": send_request() resource=" << resource << " returned ret=" << ret << dendl;
return ret;
}
return req.complete_request(y);
}
int RGWRESTReadResource::aio_read(const DoutPrefixProvider *dpp)
{
int ret = req.send_request(dpp, &conn->get_key(), headers, resource, mgr);
if (ret < 0) {
ldpp_dout(dpp, 5) << __func__ << ": send_request() resource=" << resource << " returned ret=" << ret << dendl;
return ret;
}
return 0;
}
RGWRESTSendResource::RGWRESTSendResource(RGWRESTConn *_conn,
const string& _method,
const string& _resource,
const rgw_http_param_pair *pp,
param_vec_t *extra_headers,
RGWHTTPManager *_mgr)
: cct(_conn->get_ctx()), conn(_conn), method(_method), resource(_resource),
params(make_param_list(pp)), cb(bl), mgr(_mgr),
req(cct, method.c_str(), conn->get_url(), &cb, NULL, NULL, _conn->get_api_name(), _conn->get_host_style())
{
init_common(extra_headers);
}
RGWRESTSendResource::RGWRESTSendResource(RGWRESTConn *_conn,
const string& _method,
const string& _resource,
param_vec_t& params,
param_vec_t *extra_headers,
RGWHTTPManager *_mgr)
: cct(_conn->get_ctx()), conn(_conn), method(_method), resource(_resource), params(params),
cb(bl), mgr(_mgr), req(cct, method.c_str(), conn->get_url(), &cb, NULL, NULL, _conn->get_api_name(), _conn->get_host_style())
{
init_common(extra_headers);
}
void RGWRESTSendResource::init_common(param_vec_t *extra_headers)
{
conn->populate_params(params, nullptr, conn->get_self_zonegroup());
if (extra_headers) {
headers.insert(extra_headers->begin(), extra_headers->end());
}
req.set_params(¶ms);
}
int RGWRESTSendResource::send(const DoutPrefixProvider *dpp, bufferlist& outbl, optional_yield y)
{
req.set_send_length(outbl.length());
req.set_outbl(outbl);
int ret = req.send_request(dpp, &conn->get_key(), headers, resource, mgr);
if (ret < 0) {
ldpp_dout(dpp, 5) << __func__ << ": send_request() resource=" << resource << " returned ret=" << ret << dendl;
return ret;
}
return req.complete_request(y);
}
int RGWRESTSendResource::aio_send(const DoutPrefixProvider *dpp, bufferlist& outbl)
{
req.set_send_length(outbl.length());
req.set_outbl(outbl);
int ret = req.send_request(dpp, &conn->get_key(), headers, resource, mgr);
if (ret < 0) {
ldpp_dout(dpp, 5) << __func__ << ": send_request() resource=" << resource << " returned ret=" << ret << dendl;
return ret;
}
return 0;
}
| 16,947 | 31.159393 | 203 |
cc
|
null |
ceph-main/src/rgw/rgw_rest_conn.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#pragma once
#include "rgw_rest_client.h"
#include "common/ceph_json.h"
#include "common/RefCountedObj.h"
#include "include/common_fwd.h"
#include "rgw_sal_fwd.h"
#include <atomic>
class RGWSI_Zone;
template<class T>
inline int parse_decode_json(T& t, bufferlist& bl)
{
JSONParser p;
if (!p.parse(bl.c_str(), bl.length())) {
return -EINVAL;
}
try {
decode_json_obj(t, &p);
} catch (JSONDecoder::err& e) {
return -EINVAL;
}
return 0;
}
struct rgw_http_param_pair {
const char *key;
const char *val;
};
// append a null-terminated rgw_http_param_pair list into a list of string pairs
inline void append_param_list(param_vec_t& params, const rgw_http_param_pair* pp)
{
while (pp && pp->key) {
std::string k = pp->key;
std::string v = (pp->val ? pp->val : "");
params.emplace_back(make_pair(std::move(k), std::move(v)));
++pp;
}
}
// copy a null-terminated rgw_http_param_pair list into a list of std::string pairs
inline param_vec_t make_param_list(const rgw_http_param_pair* pp)
{
param_vec_t params;
append_param_list(params, pp);
return params;
}
inline param_vec_t make_param_list(const std::map<std::string, std::string> *pp)
{
param_vec_t params;
if (!pp) {
return params;
}
for (auto iter : *pp) {
params.emplace_back(make_pair(iter.first, iter.second));
}
return params;
}
class RGWRESTConn
{
CephContext *cct;
std::vector<std::string> endpoints;
RGWAccessKey key;
std::string self_zone_group;
std::string remote_id;
std::optional<std::string> api_name;
HostStyle host_style;
std::atomic<int64_t> counter = { 0 };
public:
RGWRESTConn(CephContext *_cct,
rgw::sal::Driver* driver,
const std::string& _remote_id,
const std::list<std::string>& endpoints,
std::optional<std::string> _api_name,
HostStyle _host_style = PathStyle);
RGWRESTConn(CephContext *_cct,
const std::string& _remote_id,
const std::list<std::string>& endpoints,
RGWAccessKey _cred,
std::string _zone_group,
std::optional<std::string> _api_name,
HostStyle _host_style = PathStyle);
// custom move needed for atomic
RGWRESTConn(RGWRESTConn&& other);
RGWRESTConn& operator=(RGWRESTConn&& other);
virtual ~RGWRESTConn() = default;
int get_url(std::string& endpoint);
std::string get_url();
const std::string& get_self_zonegroup() {
return self_zone_group;
}
const std::string& get_remote_id() {
return remote_id;
}
RGWAccessKey& get_key() {
return key;
}
std::optional<std::string> get_api_name() const {
return api_name;
}
HostStyle get_host_style() {
return host_style;
}
CephContext *get_ctx() {
return cct;
}
size_t get_endpoint_count() const { return endpoints.size(); }
virtual void populate_params(param_vec_t& params, const rgw_user *uid, const std::string& zonegroup);
/* sync request */
int forward(const DoutPrefixProvider *dpp, const rgw_user& uid, req_info& info, obj_version *objv, size_t max_response, bufferlist *inbl, bufferlist *outbl, optional_yield y);
/* sync request */
int forward_iam_request(const DoutPrefixProvider *dpp, const RGWAccessKey& key, req_info& info, obj_version *objv, size_t max_response, bufferlist *inbl, bufferlist *outbl, optional_yield y);
/* async requests */
int put_obj_send_init(const rgw_obj& obj, const rgw_http_param_pair *extra_params, RGWRESTStreamS3PutObj **req);
int put_obj_async_init(const DoutPrefixProvider *dpp, const rgw_user& uid, const rgw_obj& obj,
std::map<std::string, bufferlist>& attrs, RGWRESTStreamS3PutObj **req);
int complete_request(RGWRESTStreamS3PutObj *req, std::string& etag,
ceph::real_time *mtime, optional_yield y);
struct get_obj_params {
rgw_user uid;
req_info *info{nullptr};
const ceph::real_time *mod_ptr{nullptr};
const ceph::real_time *unmod_ptr{nullptr};
bool high_precision_time{true};
std::string etag;
uint32_t mod_zone_id{0};
uint64_t mod_pg_ver{0};
bool prepend_metadata{false};
bool get_op{false};
bool rgwx_stat{false};
bool sync_manifest{false};
bool sync_cloudtiered{false};
bool skip_decrypt{true};
RGWHTTPStreamRWRequest::ReceiveCB *cb{nullptr};
bool range_is_set{false};
uint64_t range_start{0};
uint64_t range_end{0};
rgw_zone_set_entry *dst_zone_trace{nullptr};
};
int get_obj(const DoutPrefixProvider *dpp, const rgw_obj& obj, const get_obj_params& params, bool send, RGWRESTStreamRWRequest **req);
int get_obj(const DoutPrefixProvider *dpp, const rgw_user& uid, req_info *info /* optional */, const rgw_obj& obj,
const ceph::real_time *mod_ptr, const ceph::real_time *unmod_ptr,
uint32_t mod_zone_id, uint64_t mod_pg_ver,
bool prepend_metadata, bool get_op, bool rgwx_stat, bool sync_manifest,
bool skip_decrypt, rgw_zone_set_entry *dst_zone_trace, bool sync_cloudtiered,
bool send, RGWHTTPStreamRWRequest::ReceiveCB *cb, RGWRESTStreamRWRequest **req);
int complete_request(RGWRESTStreamRWRequest *req,
std::string *etag,
ceph::real_time *mtime,
uint64_t *psize,
std::map<std::string, std::string> *pattrs,
std::map<std::string, std::string> *pheaders,
optional_yield y);
int get_resource(const DoutPrefixProvider *dpp,
const std::string& resource,
param_vec_t *extra_params,
std::map<std::string, std::string>* extra_headers,
bufferlist& bl,
bufferlist *send_data,
RGWHTTPManager *mgr,
optional_yield y);
int send_resource(const DoutPrefixProvider *dpp,
const std::string& method,
const std::string& resource,
rgw_http_param_pair *extra_params,
std::map<std::string, std::string>* extra_headers,
bufferlist& bl,
bufferlist *send_data,
RGWHTTPManager *mgr,
optional_yield y);
template <class T>
int get_json_resource(const DoutPrefixProvider *dpp, const std::string& resource, param_vec_t *params,
bufferlist *in_data, optional_yield y, T& t);
template <class T>
int get_json_resource(const DoutPrefixProvider *dpp, const std::string& resource, param_vec_t *params,
optional_yield y, T& t);
template <class T>
int get_json_resource(const DoutPrefixProvider *dpp, const std::string& resource, const rgw_http_param_pair *pp,
optional_yield y, T& t);
private:
void populate_zonegroup(param_vec_t& params, const std::string& zonegroup) {
if (!zonegroup.empty()) {
params.push_back(param_pair_t(RGW_SYS_PARAM_PREFIX "zonegroup", zonegroup));
}
}
void populate_uid(param_vec_t& params, const rgw_user *uid) {
if (uid) {
std::string uid_str = uid->to_str();
if (!uid->empty()){
params.push_back(param_pair_t(RGW_SYS_PARAM_PREFIX "uid", uid_str));
}
}
}
};
class S3RESTConn : public RGWRESTConn {
public:
S3RESTConn(CephContext *_cct, rgw::sal::Driver* driver, const std::string& _remote_id, const std::list<std::string>& endpoints, std::optional<std::string> _api_name, HostStyle _host_style = PathStyle) :
RGWRESTConn(_cct, driver, _remote_id, endpoints, _api_name, _host_style) {}
S3RESTConn(CephContext *_cct, const std::string& _remote_id, const std::list<std::string>& endpoints, RGWAccessKey _cred, std::string _zone_group, std::optional<std::string> _api_name, HostStyle _host_style = PathStyle):
RGWRESTConn(_cct, _remote_id, endpoints, _cred, _zone_group, _api_name, _host_style) {}
~S3RESTConn() override = default;
void populate_params(param_vec_t& params, const rgw_user *uid, const std::string& zonegroup) override {
// do not populate any params in S3 REST Connection.
return;
}
};
template<class T>
int RGWRESTConn::get_json_resource(const DoutPrefixProvider *dpp, const std::string& resource, param_vec_t *params,
bufferlist *in_data, optional_yield y, T& t)
{
bufferlist bl;
int ret = get_resource(dpp, resource, params, nullptr, bl, in_data, nullptr, y);
if (ret < 0) {
return ret;
}
ret = parse_decode_json(t, bl);
if (ret < 0) {
return ret;
}
return 0;
}
template<class T>
int RGWRESTConn::get_json_resource(const DoutPrefixProvider *dpp, const std::string& resource, param_vec_t *params,
optional_yield y, T& t)
{
return get_json_resource(dpp, resource, params, nullptr, y, t);
}
template<class T>
int RGWRESTConn::get_json_resource(const DoutPrefixProvider *dpp, const std::string& resource, const rgw_http_param_pair *pp,
optional_yield y, T& t)
{
param_vec_t params = make_param_list(pp);
return get_json_resource(dpp, resource, ¶ms, y, t);
}
class RGWStreamIntoBufferlist : public RGWHTTPStreamRWRequest::ReceiveCB {
bufferlist& bl;
public:
explicit RGWStreamIntoBufferlist(bufferlist& _bl) : bl(_bl) {}
int handle_data(bufferlist& inbl, bool *pause) override {
bl.claim_append(inbl);
return inbl.length();
}
};
class RGWRESTReadResource : public RefCountedObject, public RGWIOProvider {
CephContext *cct;
RGWRESTConn *conn;
std::string resource;
param_vec_t params;
std::map<std::string, std::string> headers;
bufferlist bl;
RGWStreamIntoBufferlist cb;
RGWHTTPManager *mgr;
RGWRESTStreamReadRequest req;
void init_common(param_vec_t *extra_headers);
public:
RGWRESTReadResource(RGWRESTConn *_conn,
const std::string& _resource,
const rgw_http_param_pair *pp,
param_vec_t *extra_headers,
RGWHTTPManager *_mgr);
RGWRESTReadResource(RGWRESTConn *_conn,
const std::string& _resource,
param_vec_t& _params,
param_vec_t *extra_headers,
RGWHTTPManager *_mgr);
~RGWRESTReadResource() = default;
rgw_io_id get_io_id(int io_type) {
return req.get_io_id(io_type);
}
void set_io_user_info(void *user_info) override {
req.set_io_user_info(user_info);
}
void *get_io_user_info() override {
return req.get_io_user_info();
}
template <class T>
int decode_resource(T *dest);
int read(const DoutPrefixProvider *dpp, optional_yield y);
int aio_read(const DoutPrefixProvider *dpp);
std::string to_str() {
return req.to_str();
}
int get_http_status() {
return req.get_http_status();
}
int wait(bufferlist *pbl, optional_yield y) {
int ret = req.wait(y);
if (ret < 0) {
return ret;
}
if (req.get_status() < 0) {
return req.get_status();
}
*pbl = bl;
return 0;
}
template <class T>
int wait(T *dest, optional_yield y);
template <class T>
int fetch(const DoutPrefixProvider *dpp, T *dest, optional_yield y);
};
template <class T>
int RGWRESTReadResource::decode_resource(T *dest)
{
int ret = req.get_status();
if (ret < 0) {
return ret;
}
ret = parse_decode_json(*dest, bl);
if (ret < 0) {
return ret;
}
return 0;
}
template <class T>
int RGWRESTReadResource::fetch(const DoutPrefixProvider *dpp, T *dest, optional_yield y)
{
int ret = read(dpp, y);
if (ret < 0) {
return ret;
}
ret = decode_resource(dest);
if (ret < 0) {
return ret;
}
return 0;
}
template <class T>
int RGWRESTReadResource::wait(T *dest, optional_yield y)
{
int ret = req.wait(y);
if (ret < 0) {
return ret;
}
ret = decode_resource(dest);
if (ret < 0) {
return ret;
}
return 0;
}
class RGWRESTSendResource : public RefCountedObject, public RGWIOProvider {
CephContext *cct;
RGWRESTConn *conn;
std::string method;
std::string resource;
param_vec_t params;
std::map<std::string, std::string> headers;
bufferlist bl;
RGWStreamIntoBufferlist cb;
RGWHTTPManager *mgr;
RGWRESTStreamRWRequest req;
void init_common(param_vec_t *extra_headers);
public:
RGWRESTSendResource(RGWRESTConn *_conn,
const std::string& _method,
const std::string& _resource,
const rgw_http_param_pair *pp,
param_vec_t *extra_headers,
RGWHTTPManager *_mgr);
RGWRESTSendResource(RGWRESTConn *_conn,
const std::string& _method,
const std::string& _resource,
param_vec_t& params,
param_vec_t *extra_headers,
RGWHTTPManager *_mgr);
~RGWRESTSendResource() = default;
rgw_io_id get_io_id(int io_type) {
return req.get_io_id(io_type);
}
void set_io_user_info(void *user_info) override {
req.set_io_user_info(user_info);
}
void *get_io_user_info() override {
return req.get_io_user_info();
}
int send(const DoutPrefixProvider *dpp, bufferlist& bl, optional_yield y);
int aio_send(const DoutPrefixProvider *dpp, bufferlist& bl);
std::string to_str() {
return req.to_str();
}
int get_http_status() {
return req.get_http_status();
}
template <class E = int>
int wait(bufferlist *pbl, optional_yield y, E *err_result = nullptr) {
int ret = req.wait(y);
*pbl = bl;
if (ret < 0 && err_result ) {
ret = parse_decode_json(*err_result, bl);
}
return req.get_status();
}
template <class T, class E = int>
int wait(T *dest, optional_yield y, E *err_result = nullptr);
};
template <class T, class E>
int RGWRESTSendResource::wait(T *dest, optional_yield y, E *err_result)
{
int ret = req.wait(y);
if (ret >= 0) {
ret = req.get_status();
}
if (ret < 0 && err_result) {
ret = parse_decode_json(*err_result, bl);
}
if (ret < 0) {
return ret;
}
ret = parse_decode_json(*dest, bl);
if (ret < 0) {
return ret;
}
return 0;
}
class RGWRESTPostResource : public RGWRESTSendResource {
public:
RGWRESTPostResource(RGWRESTConn *_conn,
const std::string& _resource,
const rgw_http_param_pair *pp,
param_vec_t *extra_headers,
RGWHTTPManager *_mgr) : RGWRESTSendResource(_conn, "POST", _resource,
pp, extra_headers, _mgr) {}
RGWRESTPostResource(RGWRESTConn *_conn,
const std::string& _resource,
param_vec_t& params,
param_vec_t *extra_headers,
RGWHTTPManager *_mgr) : RGWRESTSendResource(_conn, "POST", _resource,
params, extra_headers, _mgr) {}
};
class RGWRESTPutResource : public RGWRESTSendResource {
public:
RGWRESTPutResource(RGWRESTConn *_conn,
const std::string& _resource,
const rgw_http_param_pair *pp,
param_vec_t *extra_headers,
RGWHTTPManager *_mgr) : RGWRESTSendResource(_conn, "PUT", _resource,
pp, extra_headers, _mgr) {}
RGWRESTPutResource(RGWRESTConn *_conn,
const std::string& _resource,
param_vec_t& params,
param_vec_t *extra_headers,
RGWHTTPManager *_mgr) : RGWRESTSendResource(_conn, "PUT", _resource,
params, extra_headers, _mgr) {}
};
class RGWRESTDeleteResource : public RGWRESTSendResource {
public:
RGWRESTDeleteResource(RGWRESTConn *_conn,
const std::string& _resource,
const rgw_http_param_pair *pp,
param_vec_t *extra_headers,
RGWHTTPManager *_mgr) : RGWRESTSendResource(_conn, "DELETE", _resource,
pp, extra_headers, _mgr) {}
RGWRESTDeleteResource(RGWRESTConn *_conn,
const std::string& _resource,
param_vec_t& params,
param_vec_t *extra_headers,
RGWHTTPManager *_mgr) : RGWRESTSendResource(_conn, "DELETE", _resource,
params, extra_headers, _mgr) {}
};
| 16,272 | 28.163082 | 222 |
h
|
null |
ceph-main/src/rgw/rgw_rest_iam.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#include <boost/tokenizer.hpp>
#include "rgw_auth_s3.h"
#include "rgw_rest_iam.h"
#include "rgw_rest_role.h"
#include "rgw_rest_user_policy.h"
#include "rgw_rest_oidc_provider.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rgw
using namespace std;
using op_generator = RGWOp*(*)(const bufferlist&);
static const std::unordered_map<std::string_view, op_generator> op_generators = {
{"CreateRole", [](const bufferlist& bl_post_body) -> RGWOp* {return new RGWCreateRole(bl_post_body);}},
{"DeleteRole", [](const bufferlist& bl_post_body) -> RGWOp* {return new RGWDeleteRole(bl_post_body);}},
{"GetRole", [](const bufferlist& bl_post_body) -> RGWOp* {return new RGWGetRole;}},
{"UpdateAssumeRolePolicy", [](const bufferlist& bl_post_body) -> RGWOp* {return new RGWModifyRoleTrustPolicy(bl_post_body);}},
{"ListRoles", [](const bufferlist& bl_post_body) -> RGWOp* {return new RGWListRoles;}},
{"PutRolePolicy", [](const bufferlist& bl_post_body) -> RGWOp* {return new RGWPutRolePolicy(bl_post_body);}},
{"GetRolePolicy", [](const bufferlist& bl_post_body) -> RGWOp* {return new RGWGetRolePolicy;}},
{"ListRolePolicies", [](const bufferlist& bl_post_body) -> RGWOp* {return new RGWListRolePolicies;}},
{"DeleteRolePolicy", [](const bufferlist& bl_post_body) -> RGWOp* {return new RGWDeleteRolePolicy(bl_post_body);}},
{"PutUserPolicy", [](const bufferlist& bl_post_body) -> RGWOp* {return new RGWPutUserPolicy;}},
{"GetUserPolicy", [](const bufferlist& bl_post_body) -> RGWOp* {return new RGWGetUserPolicy;}},
{"ListUserPolicies", [](const bufferlist& bl_post_body) -> RGWOp* {return new RGWListUserPolicies;}},
{"DeleteUserPolicy", [](const bufferlist& bl_post_body) -> RGWOp* {return new RGWDeleteUserPolicy;}},
{"CreateOpenIDConnectProvider", [](const bufferlist& bl_post_body) -> RGWOp* {return new RGWCreateOIDCProvider;}},
{"ListOpenIDConnectProviders", [](const bufferlist& bl_post_body) -> RGWOp* {return new RGWListOIDCProviders;}},
{"GetOpenIDConnectProvider", [](const bufferlist& bl_post_body) -> RGWOp* {return new RGWGetOIDCProvider;}},
{"DeleteOpenIDConnectProvider", [](const bufferlist& bl_post_body) -> RGWOp* {return new RGWDeleteOIDCProvider;}},
{"TagRole", [](const bufferlist& bl_post_body) -> RGWOp* {return new RGWTagRole(bl_post_body);}},
{"ListRoleTags", [](const bufferlist& bl_post_body) -> RGWOp* {return new RGWListRoleTags;}},
{"UntagRole", [](const bufferlist& bl_post_body) -> RGWOp* {return new RGWUntagRole(bl_post_body);}},
{"UpdateRole", [](const bufferlist& bl_post_body) -> RGWOp* {return new RGWUpdateRole(bl_post_body);}}
};
bool RGWHandler_REST_IAM::action_exists(const req_state* s)
{
if (s->info.args.exists("Action")) {
const std::string action_name = s->info.args.get("Action");
return op_generators.contains(action_name);
}
return false;
}
RGWOp *RGWHandler_REST_IAM::op_post()
{
if (s->info.args.exists("Action")) {
const std::string action_name = s->info.args.get("Action");
const auto action_it = op_generators.find(action_name);
if (action_it != op_generators.end()) {
return action_it->second(bl_post_body);
}
ldpp_dout(s, 10) << "unknown action '" << action_name << "' for IAM handler" << dendl;
} else {
ldpp_dout(s, 10) << "missing action argument in IAM handler" << dendl;
}
return nullptr;
}
int RGWHandler_REST_IAM::init(rgw::sal::Driver* driver,
req_state *s,
rgw::io::BasicClient *cio)
{
s->dialect = "iam";
s->prot_flags = RGW_REST_IAM;
return RGWHandler_REST::init(driver, s, cio);
}
int RGWHandler_REST_IAM::authorize(const DoutPrefixProvider* dpp, optional_yield y)
{
return RGW_Auth_S3::authorize(dpp, driver, auth_registry, s, y);
}
RGWHandler_REST*
RGWRESTMgr_IAM::get_handler(rgw::sal::Driver* driver,
req_state* const s,
const rgw::auth::StrategyRegistry& auth_registry,
const std::string& frontend_prefix)
{
bufferlist bl;
return new RGWHandler_REST_IAM(auth_registry, bl);
}
| 4,169 | 44.824176 | 128 |
cc
|
null |
ceph-main/src/rgw/rgw_rest_iam.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#pragma once
#include "rgw_auth.h"
#include "rgw_auth_filters.h"
#include "rgw_rest.h"
class RGWHandler_REST_IAM : public RGWHandler_REST {
const rgw::auth::StrategyRegistry& auth_registry;
bufferlist bl_post_body;
RGWOp *op_post() override;
public:
static bool action_exists(const req_state* s);
RGWHandler_REST_IAM(const rgw::auth::StrategyRegistry& auth_registry,
bufferlist& bl_post_body)
: RGWHandler_REST(),
auth_registry(auth_registry),
bl_post_body(bl_post_body) {}
~RGWHandler_REST_IAM() override = default;
int init(rgw::sal::Driver* driver,
req_state *s,
rgw::io::BasicClient *cio) override;
int authorize(const DoutPrefixProvider* dpp, optional_yield y) override;
int postauth_init(optional_yield y) override { return 0; }
};
class RGWRESTMgr_IAM : public RGWRESTMgr {
public:
RGWRESTMgr_IAM() = default;
~RGWRESTMgr_IAM() override = default;
RGWRESTMgr *get_resource_mgr(req_state* const s,
const std::string& uri,
std::string* const out_uri) override {
return this;
}
RGWHandler_REST* get_handler(rgw::sal::Driver* driver,
req_state*,
const rgw::auth::StrategyRegistry&,
const std::string&) override;
};
| 1,445 | 28.510204 | 74 |
h
|
null |
ceph-main/src/rgw/rgw_rest_info.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#include "rgw_op.h"
#include "rgw_rest_info.h"
#include "rgw_sal.h"
#define dout_subsys ceph_subsys_rgw
class RGWOp_Info_Get : public RGWRESTOp {
public:
RGWOp_Info_Get() {}
int check_caps(const RGWUserCaps& caps) override {
return caps.check_cap("info", RGW_CAP_READ);
}
void execute(optional_yield y) override;
const char* name() const override { return "get_info"; }
};
void RGWOp_Info_Get::execute(optional_yield y) {
Formatter *formatter = flusher.get_formatter();
flusher.start(0);
/* extensible array of general info sections, currently only
* storage backend is defined:
* {"info":{"storage_backends":[{"name":"rados","cluster_id":"75d1938b-2949-4933-8386-fb2d1449ff03"}]}}
*/
formatter->open_object_section("dummy");
formatter->open_object_section("info");
formatter->open_array_section("storage_backends");
// for now, just return the backend that is accessible
formatter->open_object_section("dummy");
formatter->dump_string("name", driver->get_name());
formatter->dump_string("cluster_id", driver->get_cluster_id(this, y));
formatter->close_section();
formatter->close_section();
formatter->close_section();
formatter->close_section();
flusher.flush();
} /* RGWOp_Info_Get::execute */
RGWOp *RGWHandler_Info::op_get()
{
return new RGWOp_Info_Get;
}
| 1,431 | 27.64 | 105 |
cc
|
null |
ceph-main/src/rgw/rgw_rest_info.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#pragma once
#include "rgw_rest.h"
#include "rgw_rest_s3.h"
class RGWHandler_Info : public RGWHandler_Auth_S3 {
protected:
RGWOp *op_get() override;
public:
using RGWHandler_Auth_S3::RGWHandler_Auth_S3;
~RGWHandler_Info() override = default;
int read_permissions(RGWOp*, optional_yield) override {
return 0;
}
};
class RGWRESTMgr_Info : public RGWRESTMgr {
public:
RGWRESTMgr_Info() = default;
~RGWRESTMgr_Info() override = default;
RGWHandler_REST* get_handler(rgw::sal::Driver* driver,
req_state*,
const rgw::auth::StrategyRegistry& auth_registry,
const std::string&) override {
return new RGWHandler_Info(auth_registry);
}
};
| 839 | 23.705882 | 80 |
h
|
null |
ceph-main/src/rgw/rgw_rest_metadata.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2013 eNovance SAS <[email protected]>
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "include/page.h"
#include "rgw_rest.h"
#include "rgw_op.h"
#include "rgw_rest_s3.h"
#include "rgw_rest_metadata.h"
#include "rgw_client_io.h"
#include "rgw_mdlog_types.h"
#include "rgw_sal_rados.h"
#include "common/errno.h"
#include "common/strtol.h"
#include "rgw/rgw_b64.h"
#include "include/ceph_assert.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rgw
using namespace std;
static inline void frame_metadata_key(req_state *s, string& out) {
bool exists;
string key = s->info.args.get("key", &exists);
string section;
if (!s->init_state.url_bucket.empty()) {
section = s->init_state.url_bucket;
} else {
section = key;
key.clear();
}
out = section;
if (!key.empty()) {
out += string(":") + key;
}
}
void RGWOp_Metadata_Get::execute(optional_yield y) {
string metadata_key;
frame_metadata_key(s, metadata_key);
auto meta_mgr = static_cast<rgw::sal::RadosStore*>(driver)->ctl()->meta.mgr;
/* Get keys */
op_ret = meta_mgr->get(metadata_key, s->formatter, s->yield, s);
if (op_ret < 0) {
ldpp_dout(s, 5) << "ERROR: can't get key: " << cpp_strerror(op_ret) << dendl;
return;
}
op_ret = 0;
}
void RGWOp_Metadata_Get_Myself::execute(optional_yield y) {
string owner_id;
owner_id = s->owner.get_id().to_str();
s->info.args.append("key", owner_id);
return RGWOp_Metadata_Get::execute(y);
}
void RGWOp_Metadata_List::execute(optional_yield y) {
string marker;
ldpp_dout(this, 16) << __func__
<< " raw marker " << s->info.args.get("marker")
<< dendl;
try {
marker = s->info.args.get("marker");
if (!marker.empty()) {
marker = rgw::from_base64(marker);
}
ldpp_dout(this, 16) << __func__
<< " marker " << marker << dendl;
} catch (...) {
marker = std::string("");
}
bool max_entries_specified;
string max_entries_str =
s->info.args.get("max-entries", &max_entries_specified);
bool extended_response = (max_entries_specified); /* for backward compatibility, if max-entries is not specified
we will send the old response format */
uint64_t max_entries = 0;
if (max_entries_specified) {
string err;
max_entries = (unsigned)strict_strtol(max_entries_str.c_str(), 10, &err);
if (!err.empty()) {
ldpp_dout(this, 5) << "Error parsing max-entries " << max_entries_str << dendl;
op_ret = -EINVAL;
return;
}
}
string metadata_key;
frame_metadata_key(s, metadata_key);
/* List keys */
void *handle;
int max = 1000;
/* example markers:
marker = "3:b55a9110:root::bu_9:head";
marker = "3:b9a8b2a6:root::sorry_janefonda_890:head";
marker = "3:bf885d8f:root::sorry_janefonda_665:head";
*/
op_ret = driver->meta_list_keys_init(this, metadata_key, marker, &handle);
if (op_ret < 0) {
ldpp_dout(this, 5) << "ERROR: can't get key: " << cpp_strerror(op_ret) << dendl;
return;
}
bool truncated;
uint64_t count = 0;
if (extended_response) {
s->formatter->open_object_section("result");
}
s->formatter->open_array_section("keys");
uint64_t left;
do {
list<string> keys;
left = (max_entries_specified ? max_entries - count : max);
op_ret = driver->meta_list_keys_next(this, handle, left, keys, &truncated);
if (op_ret < 0) {
ldpp_dout(this, 5) << "ERROR: lists_keys_next(): " << cpp_strerror(op_ret)
<< dendl;
return;
}
for (list<string>::iterator iter = keys.begin(); iter != keys.end();
++iter) {
s->formatter->dump_string("key", *iter);
++count;
}
} while (truncated && left > 0);
s->formatter->close_section();
if (extended_response) {
encode_json("truncated", truncated, s->formatter);
encode_json("count", count, s->formatter);
if (truncated) {
string esc_marker =
rgw::to_base64(driver->meta_get_marker(handle));
encode_json("marker", esc_marker, s->formatter);
}
s->formatter->close_section();
}
driver->meta_list_keys_complete(handle);
op_ret = 0;
}
int RGWOp_Metadata_Put::get_data(bufferlist& bl) {
size_t cl = 0;
char *data;
int read_len;
if (s->length)
cl = atoll(s->length);
if (cl) {
data = (char *)malloc(cl + 1);
if (!data) {
return -ENOMEM;
}
read_len = recv_body(s, data, cl);
if (cl != (size_t)read_len) {
ldpp_dout(this, 10) << "recv_body incomplete" << dendl;
}
if (read_len < 0) {
free(data);
return read_len;
}
bl.append(data, read_len);
} else {
int chunk_size = CEPH_PAGE_SIZE;
const char *enc = s->info.env->get("HTTP_TRANSFER_ENCODING");
if (!enc || strcmp(enc, "chunked")) {
return -ERR_LENGTH_REQUIRED;
}
data = (char *)malloc(chunk_size);
if (!data) {
return -ENOMEM;
}
do {
read_len = recv_body(s, data, chunk_size);
if (read_len < 0) {
free(data);
return read_len;
}
bl.append(data, read_len);
} while (read_len == chunk_size);
}
free(data);
return 0;
}
static bool string_to_sync_type(const string& sync_string,
RGWMDLogSyncType& type) {
if (sync_string.compare("update-by-version") == 0)
type = APPLY_UPDATES;
else if (sync_string.compare("update-by-timestamp") == 0)
type = APPLY_NEWER;
else if (sync_string.compare("always") == 0)
type = APPLY_ALWAYS;
else
return false;
return true;
}
void RGWOp_Metadata_Put::execute(optional_yield y) {
bufferlist bl;
string metadata_key;
op_ret = get_data(bl);
if (op_ret < 0) {
return;
}
op_ret = do_aws4_auth_completion();
if (op_ret < 0) {
return;
}
frame_metadata_key(s, metadata_key);
RGWMDLogSyncType sync_type = RGWMDLogSyncType::APPLY_ALWAYS;
bool mode_exists = false;
string mode_string = s->info.args.get("update-type", &mode_exists);
if (mode_exists) {
bool parsed = string_to_sync_type(mode_string,
sync_type);
if (!parsed) {
op_ret = -EINVAL;
return;
}
}
op_ret = static_cast<rgw::sal::RadosStore*>(driver)->ctl()->meta.mgr->put(metadata_key, bl, s->yield, s, sync_type,
false, &ondisk_version);
if (op_ret < 0) {
ldpp_dout(s, 5) << "ERROR: can't put key: " << cpp_strerror(op_ret) << dendl;
return;
}
// translate internal codes into return header
if (op_ret == STATUS_NO_APPLY)
update_status = "skipped";
else if (op_ret == STATUS_APPLIED)
update_status = "applied";
}
void RGWOp_Metadata_Put::send_response() {
int op_return_code = op_ret;
if ((op_ret == STATUS_NO_APPLY) || (op_ret == STATUS_APPLIED))
op_return_code = STATUS_NO_CONTENT;
set_req_state_err(s, op_return_code);
dump_errno(s);
stringstream ver_stream;
ver_stream << "ver:" << ondisk_version.ver
<<",tag:" << ondisk_version.tag;
dump_header_if_nonempty(s, "RGWX_UPDATE_STATUS", update_status);
dump_header_if_nonempty(s, "RGWX_UPDATE_VERSION", ver_stream.str());
end_header(s);
}
void RGWOp_Metadata_Delete::execute(optional_yield y) {
string metadata_key;
frame_metadata_key(s, metadata_key);
op_ret = static_cast<rgw::sal::RadosStore*>(driver)->ctl()->meta.mgr->remove(metadata_key, s->yield, s);
if (op_ret < 0) {
ldpp_dout(s, 5) << "ERROR: can't remove key: " << cpp_strerror(op_ret) << dendl;
return;
}
op_ret = 0;
}
RGWOp *RGWHandler_Metadata::op_get() {
if (s->info.args.exists("myself"))
return new RGWOp_Metadata_Get_Myself;
if (s->info.args.exists("key"))
return new RGWOp_Metadata_Get;
else
return new RGWOp_Metadata_List;
}
RGWOp *RGWHandler_Metadata::op_put() {
return new RGWOp_Metadata_Put;
}
RGWOp *RGWHandler_Metadata::op_delete() {
return new RGWOp_Metadata_Delete;
}
| 8,238 | 24.586957 | 117 |
cc
|
null |
ceph-main/src/rgw/rgw_rest_metadata.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2013 eNovance SAS <[email protected]>
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#pragma once
#include "rgw/rgw_rest.h"
#include "rgw/rgw_auth_s3.h"
class RGWOp_Metadata_List : public RGWRESTOp {
public:
RGWOp_Metadata_List() {}
~RGWOp_Metadata_List() override {}
int check_caps(const RGWUserCaps& caps) override {
return caps.check_cap("metadata", RGW_CAP_READ);
}
void execute(optional_yield y) override;
const char* name() const override { return "list_metadata"; }
};
class RGWOp_Metadata_Get : public RGWRESTOp {
public:
RGWOp_Metadata_Get() {}
~RGWOp_Metadata_Get() override {}
int check_caps(const RGWUserCaps& caps) override {
return caps.check_cap("metadata", RGW_CAP_READ);
}
void execute(optional_yield y) override;
const char* name() const override { return "get_metadata"; }
};
class RGWOp_Metadata_Get_Myself : public RGWOp_Metadata_Get {
public:
RGWOp_Metadata_Get_Myself() {}
~RGWOp_Metadata_Get_Myself() override {}
void execute(optional_yield y) override;
};
class RGWOp_Metadata_Put : public RGWRESTOp {
int get_data(bufferlist& bl);
std::string update_status;
obj_version ondisk_version;
public:
RGWOp_Metadata_Put() {}
~RGWOp_Metadata_Put() override {}
int check_caps(const RGWUserCaps& caps) override {
return caps.check_cap("metadata", RGW_CAP_WRITE);
}
void execute(optional_yield y) override;
void send_response() override;
const char* name() const override { return "set_metadata"; }
RGWOpType get_type() override { return RGW_OP_ADMIN_SET_METADATA; }
};
class RGWOp_Metadata_Delete : public RGWRESTOp {
public:
RGWOp_Metadata_Delete() {}
~RGWOp_Metadata_Delete() override {}
int check_caps(const RGWUserCaps& caps) override {
return caps.check_cap("metadata", RGW_CAP_WRITE);
}
void execute(optional_yield y) override;
const char* name() const override { return "remove_metadata"; }
};
class RGWHandler_Metadata : public RGWHandler_Auth_S3 {
protected:
RGWOp *op_get() override;
RGWOp *op_put() override;
RGWOp *op_delete() override;
int read_permissions(RGWOp*, optional_yield y) override {
return 0;
}
public:
using RGWHandler_Auth_S3::RGWHandler_Auth_S3;
~RGWHandler_Metadata() override = default;
};
class RGWRESTMgr_Metadata : public RGWRESTMgr {
public:
RGWRESTMgr_Metadata() = default;
~RGWRESTMgr_Metadata() override = default;
RGWHandler_REST* get_handler(rgw::sal::Driver* driver,
req_state* const s,
const rgw::auth::StrategyRegistry& auth_registry,
const std::string& frontend_prefix) override {
return new RGWHandler_Metadata(auth_registry);
}
};
| 3,039 | 27.148148 | 80 |
h
|
null |
ceph-main/src/rgw/rgw_rest_oidc_provider.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#include <errno.h>
#include "common/errno.h"
#include "common/Formatter.h"
#include "common/ceph_json.h"
#include "include/types.h"
#include "rgw_string.h"
#include "rgw_common.h"
#include "rgw_op.h"
#include "rgw_rest.h"
#include "rgw_role.h"
#include "rgw_rest_oidc_provider.h"
#include "rgw_oidc_provider.h"
#include "rgw_sal.h"
#define dout_subsys ceph_subsys_rgw
using namespace std;
int RGWRestOIDCProvider::verify_permission(optional_yield y)
{
if (s->auth.identity->is_anonymous()) {
return -EACCES;
}
provider_arn = s->info.args.get("OpenIDConnectProviderArn");
if (provider_arn.empty()) {
ldpp_dout(this, 20) << "ERROR: Provider ARN is empty"<< dendl;
return -EINVAL;
}
auto ret = check_caps(s->user->get_caps());
if (ret == 0) {
return ret;
}
uint64_t op = get_op();
auto rgw_arn = rgw::ARN::parse(provider_arn, true);
if (rgw_arn) {
if (!verify_user_permission(this, s, *rgw_arn, op)) {
return -EACCES;
}
} else {
return -EACCES;
}
return 0;
}
void RGWRestOIDCProvider::send_response()
{
if (op_ret) {
set_req_state_err(s, op_ret);
}
dump_errno(s);
end_header(s, this);
}
int RGWRestOIDCProviderRead::check_caps(const RGWUserCaps& caps)
{
return caps.check_cap("oidc-provider", RGW_CAP_READ);
}
int RGWRestOIDCProviderWrite::check_caps(const RGWUserCaps& caps)
{
return caps.check_cap("oidc-provider", RGW_CAP_WRITE);
}
int RGWCreateOIDCProvider::verify_permission(optional_yield y)
{
if (s->auth.identity->is_anonymous()) {
return -EACCES;
}
auto ret = check_caps(s->user->get_caps());
if (ret == 0) {
return ret;
}
string idp_url = url_remove_prefix(provider_url);
if (!verify_user_permission(this,
s,
rgw::ARN(idp_url,
"oidc-provider",
s->user->get_tenant(), true),
get_op())) {
return -EACCES;
}
return 0;
}
int RGWCreateOIDCProvider::get_params()
{
provider_url = s->info.args.get("Url");
auto val_map = s->info.args.get_params();
for (auto& it : val_map) {
if (it.first.find("ClientIDList.member.") != string::npos) {
client_ids.emplace_back(it.second);
}
if (it.first.find("ThumbprintList.member.") != string::npos) {
thumbprints.emplace_back(it.second);
}
}
if (provider_url.empty() || thumbprints.empty()) {
ldpp_dout(this, 20) << "ERROR: one of url or thumbprints is empty" << dendl;
return -EINVAL;
}
return 0;
}
void RGWCreateOIDCProvider::execute(optional_yield y)
{
op_ret = get_params();
if (op_ret < 0) {
return;
}
std::unique_ptr<rgw::sal::RGWOIDCProvider> provider = driver->get_oidc_provider();
provider->set_url(provider_url);
provider->set_tenant(s->user->get_tenant());
provider->set_client_ids(client_ids);
provider->set_thumbprints(thumbprints);
op_ret = provider->create(s, true, y);
if (op_ret == 0) {
s->formatter->open_object_section("CreateOpenIDConnectProviderResponse");
s->formatter->open_object_section("CreateOpenIDConnectProviderResult");
provider->dump(s->formatter);
s->formatter->close_section();
s->formatter->open_object_section("ResponseMetadata");
s->formatter->dump_string("RequestId", s->trans_id);
s->formatter->close_section();
s->formatter->close_section();
}
}
void RGWDeleteOIDCProvider::execute(optional_yield y)
{
std::unique_ptr<rgw::sal::RGWOIDCProvider> provider = driver->get_oidc_provider();
provider->set_arn(provider_arn);
provider->set_tenant(s->user->get_tenant());
op_ret = provider->delete_obj(s, y);
if (op_ret < 0 && op_ret != -ENOENT && op_ret != -EINVAL) {
op_ret = ERR_INTERNAL_ERROR;
}
if (op_ret == 0) {
s->formatter->open_object_section("DeleteOpenIDConnectProviderResponse");
s->formatter->open_object_section("ResponseMetadata");
s->formatter->dump_string("RequestId", s->trans_id);
s->formatter->close_section();
s->formatter->close_section();
}
}
void RGWGetOIDCProvider::execute(optional_yield y)
{
std::unique_ptr<rgw::sal::RGWOIDCProvider> provider = driver->get_oidc_provider();
provider->set_arn(provider_arn);
provider->set_tenant(s->user->get_tenant());
op_ret = provider->get(s, y);
if (op_ret < 0 && op_ret != -ENOENT && op_ret != -EINVAL) {
op_ret = ERR_INTERNAL_ERROR;
}
if (op_ret == 0) {
s->formatter->open_object_section("GetOpenIDConnectProviderResponse");
s->formatter->open_object_section("ResponseMetadata");
s->formatter->dump_string("RequestId", s->trans_id);
s->formatter->close_section();
s->formatter->open_object_section("GetOpenIDConnectProviderResult");
provider->dump_all(s->formatter);
s->formatter->close_section();
s->formatter->close_section();
}
}
int RGWListOIDCProviders::verify_permission(optional_yield y)
{
if (s->auth.identity->is_anonymous()) {
return -EACCES;
}
if (int ret = check_caps(s->user->get_caps()); ret == 0) {
return ret;
}
if (!verify_user_permission(this,
s,
rgw::ARN(),
get_op())) {
return -EACCES;
}
return 0;
}
void RGWListOIDCProviders::execute(optional_yield y)
{
vector<std::unique_ptr<rgw::sal::RGWOIDCProvider>> result;
op_ret = driver->get_oidc_providers(s, s->user->get_tenant(), result, y);
if (op_ret == 0) {
s->formatter->open_array_section("ListOpenIDConnectProvidersResponse");
s->formatter->open_object_section("ResponseMetadata");
s->formatter->dump_string("RequestId", s->trans_id);
s->formatter->close_section();
s->formatter->open_object_section("ListOpenIDConnectProvidersResult");
s->formatter->open_array_section("OpenIDConnectProviderList");
for (const auto& it : result) {
s->formatter->open_object_section("member");
auto& arn = it->get_arn();
ldpp_dout(s, 0) << "ARN: " << arn << dendl;
s->formatter->dump_string("Arn", arn);
s->formatter->close_section();
}
s->formatter->close_section();
s->formatter->close_section();
s->formatter->close_section();
}
}
| 6,376 | 26.252137 | 84 |
cc
|
null |
ceph-main/src/rgw/rgw_rest_oidc_provider.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#pragma once
#include "rgw_rest.h"
#include "rgw_oidc_provider.h"
class RGWRestOIDCProvider : public RGWRESTOp {
protected:
std::vector<std::string> client_ids;
std::vector<std::string> thumbprints;
std::string provider_url; //'iss' field in JWT
std::string provider_arn;
public:
int verify_permission(optional_yield y) override;
void send_response() override;
virtual uint64_t get_op() = 0;
};
class RGWRestOIDCProviderRead : public RGWRestOIDCProvider {
public:
RGWRestOIDCProviderRead() = default;
int check_caps(const RGWUserCaps& caps) override;
};
class RGWRestOIDCProviderWrite : public RGWRestOIDCProvider {
public:
RGWRestOIDCProviderWrite() = default;
int check_caps(const RGWUserCaps& caps) override;
};
class RGWCreateOIDCProvider : public RGWRestOIDCProviderWrite {
public:
RGWCreateOIDCProvider() = default;
int verify_permission(optional_yield y) override;
void execute(optional_yield y) override;
int get_params();
const char* name() const override { return "create_oidc_provider"; }
RGWOpType get_type() override { return RGW_OP_CREATE_OIDC_PROVIDER; }
uint64_t get_op() override { return rgw::IAM::iamCreateOIDCProvider; }
};
class RGWDeleteOIDCProvider : public RGWRestOIDCProviderWrite {
public:
RGWDeleteOIDCProvider() = default;
void execute(optional_yield y) override;
const char* name() const override { return "delete_oidc_provider"; }
RGWOpType get_type() override { return RGW_OP_DELETE_OIDC_PROVIDER; }
uint64_t get_op() override { return rgw::IAM::iamDeleteOIDCProvider; }
};
class RGWGetOIDCProvider : public RGWRestOIDCProviderRead {
public:
RGWGetOIDCProvider() = default;
void execute(optional_yield y) override;
const char* name() const override { return "get_oidc_provider"; }
RGWOpType get_type() override { return RGW_OP_GET_OIDC_PROVIDER; }
uint64_t get_op() override { return rgw::IAM::iamGetOIDCProvider; }
};
class RGWListOIDCProviders : public RGWRestOIDCProviderRead {
public:
RGWListOIDCProviders() = default;
int verify_permission(optional_yield y) override;
void execute(optional_yield y) override;
int get_params();
const char* name() const override { return "list_oidc_providers"; }
RGWOpType get_type() override { return RGW_OP_LIST_OIDC_PROVIDERS; }
uint64_t get_op() override { return rgw::IAM::iamListOIDCProviders; }
};
| 2,457 | 33.138889 | 72 |
h
|
null |
ceph-main/src/rgw/rgw_rest_pubsub.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include <algorithm>
#include <boost/tokenizer.hpp>
#include <optional>
#include "rgw_rest_pubsub.h"
#include "rgw_pubsub_push.h"
#include "rgw_pubsub.h"
#include "rgw_op.h"
#include "rgw_rest.h"
#include "rgw_rest_s3.h"
#include "rgw_arn.h"
#include "rgw_auth_s3.h"
#include "rgw_notify.h"
#include "services/svc_zone.h"
#include "common/dout.h"
#include "rgw_url.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rgw
static const char* AWS_SNS_NS("https://sns.amazonaws.com/doc/2010-03-31/");
bool verify_transport_security(CephContext *cct, const RGWEnv& env) {
const auto is_secure = rgw_transport_is_secure(cct, env);
if (!is_secure && g_conf().get_val<bool>("rgw_allow_notification_secrets_in_cleartext")) {
ldout(cct, 0) << "WARNING: bypassing endpoint validation, allows sending secrets over insecure transport" << dendl;
return true;
}
return is_secure;
}
// make sure that endpoint is a valid URL
// make sure that if user/password are passed inside URL, it is over secure connection
// update rgw_pubsub_dest to indicate that a password is stored in the URL
bool validate_and_update_endpoint_secret(rgw_pubsub_dest& dest, CephContext *cct, const RGWEnv& env) {
if (dest.push_endpoint.empty()) {
return true;
}
std::string user;
std::string password;
if (!rgw::parse_url_userinfo(dest.push_endpoint, user, password)) {
ldout(cct, 1) << "endpoint validation error: malformed endpoint URL:" << dest.push_endpoint << dendl;
return false;
}
// this should be verified inside parse_url()
ceph_assert(user.empty() == password.empty());
if (!user.empty()) {
dest.stored_secret = true;
if (!verify_transport_security(cct, env)) {
ldout(cct, 1) << "endpoint validation error: sending secrets over insecure transport" << dendl;
return false;
}
}
return true;
}
bool topic_has_endpoint_secret(const rgw_pubsub_topic& topic) {
return topic.dest.stored_secret;
}
bool topics_has_endpoint_secret(const rgw_pubsub_topics& topics) {
for (const auto& topic : topics.topics) {
if (topic_has_endpoint_secret(topic.second)) return true;
}
return false;
}
// command (AWS compliant):
// POST
// Action=CreateTopic&Name=<topic-name>[&OpaqueData=data][&push-endpoint=<endpoint>[&persistent][&<arg1>=<value1>]]
class RGWPSCreateTopicOp : public RGWOp {
private:
std::string topic_name;
rgw_pubsub_dest dest;
std::string topic_arn;
std::string opaque_data;
int get_params() {
topic_name = s->info.args.get("Name");
if (topic_name.empty()) {
ldpp_dout(this, 1) << "CreateTopic Action 'Name' argument is missing" << dendl;
return -EINVAL;
}
opaque_data = s->info.args.get("OpaqueData");
dest.push_endpoint = s->info.args.get("push-endpoint");
s->info.args.get_bool("persistent", &dest.persistent, false);
if (!validate_and_update_endpoint_secret(dest, s->cct, *(s->info.env))) {
return -EINVAL;
}
for (const auto& param : s->info.args.get_params()) {
if (param.first == "Action" || param.first == "Name" || param.first == "PayloadHash") {
continue;
}
dest.push_endpoint_args.append(param.first+"="+param.second+"&");
}
if (!dest.push_endpoint_args.empty()) {
// remove last separator
dest.push_endpoint_args.pop_back();
}
if (!dest.push_endpoint.empty() && dest.persistent) {
const auto ret = rgw::notify::add_persistent_topic(topic_name, s->yield);
if (ret < 0) {
ldpp_dout(this, 1) << "CreateTopic Action failed to create queue for persistent topics. error:" << ret << dendl;
return ret;
}
}
// dest object only stores endpoint info
dest.arn_topic = topic_name;
// the topic ARN will be sent in the reply
const rgw::ARN arn(rgw::Partition::aws, rgw::Service::sns,
driver->get_zone()->get_zonegroup().get_name(),
s->user->get_tenant(), topic_name);
topic_arn = arn.to_string();
return 0;
}
public:
int verify_permission(optional_yield) override {
return 0;
}
void pre_exec() override {
rgw_bucket_object_pre_exec(s);
}
void execute(optional_yield) override;
const char* name() const override { return "pubsub_topic_create"; }
RGWOpType get_type() override { return RGW_OP_PUBSUB_TOPIC_CREATE; }
uint32_t op_mask() override { return RGW_OP_TYPE_WRITE; }
void send_response() override {
if (op_ret) {
set_req_state_err(s, op_ret);
}
dump_errno(s);
end_header(s, this, "application/xml");
if (op_ret < 0) {
return;
}
const auto f = s->formatter;
f->open_object_section_in_ns("CreateTopicResponse", AWS_SNS_NS);
f->open_object_section("CreateTopicResult");
encode_xml("TopicArn", topic_arn, f);
f->close_section(); // CreateTopicResult
f->open_object_section("ResponseMetadata");
encode_xml("RequestId", s->req_id, f);
f->close_section(); // ResponseMetadata
f->close_section(); // CreateTopicResponse
rgw_flush_formatter_and_reset(s, f);
}
};
void RGWPSCreateTopicOp::execute(optional_yield y) {
op_ret = get_params();
if (op_ret < 0) {
return;
}
const RGWPubSub ps(driver, s->owner.get_id().tenant);
op_ret = ps.create_topic(this, topic_name, dest, topic_arn, opaque_data, y);
if (op_ret < 0) {
ldpp_dout(this, 1) << "failed to create topic '" << topic_name << "', ret=" << op_ret << dendl;
return;
}
ldpp_dout(this, 20) << "successfully created topic '" << topic_name << "'" << dendl;
}
// command (AWS compliant):
// POST
// Action=ListTopics
class RGWPSListTopicsOp : public RGWOp {
private:
rgw_pubsub_topics result;
public:
int verify_permission(optional_yield) override {
return 0;
}
void pre_exec() override {
rgw_bucket_object_pre_exec(s);
}
void execute(optional_yield) override;
const char* name() const override { return "pubsub_topics_list"; }
RGWOpType get_type() override { return RGW_OP_PUBSUB_TOPICS_LIST; }
uint32_t op_mask() override { return RGW_OP_TYPE_READ; }
void send_response() override {
if (op_ret) {
set_req_state_err(s, op_ret);
}
dump_errno(s);
end_header(s, this, "application/xml");
if (op_ret < 0) {
return;
}
const auto f = s->formatter;
f->open_object_section_in_ns("ListTopicsResponse", AWS_SNS_NS);
f->open_object_section("ListTopicsResult");
encode_xml("Topics", result, f);
f->close_section(); // ListTopicsResult
f->open_object_section("ResponseMetadata");
encode_xml("RequestId", s->req_id, f);
f->close_section(); // ResponseMetadat
f->close_section(); // ListTopicsResponse
rgw_flush_formatter_and_reset(s, f);
}
};
void RGWPSListTopicsOp::execute(optional_yield y) {
const RGWPubSub ps(driver, s->owner.get_id().tenant);
op_ret = ps.get_topics(this, result, y);
// if there are no topics it is not considered an error
op_ret = op_ret == -ENOENT ? 0 : op_ret;
if (op_ret < 0) {
ldpp_dout(this, 1) << "failed to get topics, ret=" << op_ret << dendl;
return;
}
if (topics_has_endpoint_secret(result) && !verify_transport_security(s->cct, *(s->info.env))) {
ldpp_dout(this, 1) << "topics contain secrets and cannot be sent over insecure transport" << dendl;
op_ret = -EPERM;
return;
}
ldpp_dout(this, 20) << "successfully got topics" << dendl;
}
// command (extension to AWS):
// POST
// Action=GetTopic&TopicArn=<topic-arn>
class RGWPSGetTopicOp : public RGWOp {
private:
std::string topic_name;
rgw_pubsub_topic result;
int get_params() {
const auto topic_arn = rgw::ARN::parse((s->info.args.get("TopicArn")));
if (!topic_arn || topic_arn->resource.empty()) {
ldpp_dout(this, 1) << "GetTopic Action 'TopicArn' argument is missing or invalid" << dendl;
return -EINVAL;
}
topic_name = topic_arn->resource;
return 0;
}
public:
int verify_permission(optional_yield y) override {
return 0;
}
void pre_exec() override {
rgw_bucket_object_pre_exec(s);
}
void execute(optional_yield y) override;
const char* name() const override { return "pubsub_topic_get"; }
RGWOpType get_type() override { return RGW_OP_PUBSUB_TOPIC_GET; }
uint32_t op_mask() override { return RGW_OP_TYPE_READ; }
void send_response() override {
if (op_ret) {
set_req_state_err(s, op_ret);
}
dump_errno(s);
end_header(s, this, "application/xml");
if (op_ret < 0) {
return;
}
const auto f = s->formatter;
f->open_object_section("GetTopicResponse");
f->open_object_section("GetTopicResult");
encode_xml("Topic", result, f);
f->close_section();
f->open_object_section("ResponseMetadata");
encode_xml("RequestId", s->req_id, f);
f->close_section();
f->close_section();
rgw_flush_formatter_and_reset(s, f);
}
};
void RGWPSGetTopicOp::execute(optional_yield y) {
op_ret = get_params();
if (op_ret < 0) {
return;
}
const RGWPubSub ps(driver, s->owner.get_id().tenant);
op_ret = ps.get_topic(this, topic_name, result, y);
if (op_ret < 0) {
ldpp_dout(this, 1) << "failed to get topic '" << topic_name << "', ret=" << op_ret << dendl;
return;
}
if (topic_has_endpoint_secret(result) && !verify_transport_security(s->cct, *(s->info.env))) {
ldpp_dout(this, 1) << "topic '" << topic_name << "' contain secret and cannot be sent over insecure transport" << dendl;
op_ret = -EPERM;
return;
}
ldpp_dout(this, 1) << "successfully got topic '" << topic_name << "'" << dendl;
}
// command (AWS compliant):
// POST
// Action=GetTopicAttributes&TopicArn=<topic-arn>
class RGWPSGetTopicAttributesOp : public RGWOp {
private:
std::string topic_name;
rgw_pubsub_topic result;
int get_params() {
const auto topic_arn = rgw::ARN::parse((s->info.args.get("TopicArn")));
if (!topic_arn || topic_arn->resource.empty()) {
ldpp_dout(this, 1) << "GetTopicAttribute Action 'TopicArn' argument is missing or invalid" << dendl;
return -EINVAL;
}
topic_name = topic_arn->resource;
return 0;
}
public:
int verify_permission(optional_yield y) override {
return 0;
}
void pre_exec() override {
rgw_bucket_object_pre_exec(s);
}
void execute(optional_yield y) override;
const char* name() const override { return "pubsub_topic_get"; }
RGWOpType get_type() override { return RGW_OP_PUBSUB_TOPIC_GET; }
uint32_t op_mask() override { return RGW_OP_TYPE_READ; }
void send_response() override {
if (op_ret) {
set_req_state_err(s, op_ret);
}
dump_errno(s);
end_header(s, this, "application/xml");
if (op_ret < 0) {
return;
}
const auto f = s->formatter;
f->open_object_section_in_ns("GetTopicAttributesResponse", AWS_SNS_NS);
f->open_object_section("GetTopicAttributesResult");
result.dump_xml_as_attributes(f);
f->close_section(); // GetTopicAttributesResult
f->open_object_section("ResponseMetadata");
encode_xml("RequestId", s->req_id, f);
f->close_section(); // ResponseMetadata
f->close_section(); // GetTopicAttributesResponse
rgw_flush_formatter_and_reset(s, f);
}
};
void RGWPSGetTopicAttributesOp::execute(optional_yield y) {
op_ret = get_params();
if (op_ret < 0) {
return;
}
const RGWPubSub ps(driver, s->owner.get_id().tenant);
op_ret = ps.get_topic(this, topic_name, result, y);
if (op_ret < 0) {
ldpp_dout(this, 1) << "failed to get topic '" << topic_name << "', ret=" << op_ret << dendl;
return;
}
if (topic_has_endpoint_secret(result) && !verify_transport_security(s->cct, *(s->info.env))) {
ldpp_dout(this, 1) << "topic '" << topic_name << "' contain secret and cannot be sent over insecure transport" << dendl;
op_ret = -EPERM;
return;
}
ldpp_dout(this, 1) << "successfully got topic '" << topic_name << "'" << dendl;
}
// command (AWS compliant):
// POST
// Action=DeleteTopic&TopicArn=<topic-arn>
class RGWPSDeleteTopicOp : public RGWOp {
private:
std::string topic_name;
int get_params() {
const auto topic_arn = rgw::ARN::parse((s->info.args.get("TopicArn")));
if (!topic_arn || topic_arn->resource.empty()) {
ldpp_dout(this, 1) << "DeleteTopic Action 'TopicArn' argument is missing or invalid" << dendl;
return -EINVAL;
}
topic_name = topic_arn->resource;
// upon deletion it is not known if topic is persistent or not
// will try to delete the persistent topic anyway
const auto ret = rgw::notify::remove_persistent_topic(topic_name, s->yield);
if (ret == -ENOENT) {
// topic was not persistent, or already deleted
return 0;
}
if (ret < 0) {
ldpp_dout(this, 1) << "DeleteTopic Action failed to remove queue for persistent topics. error:" << ret << dendl;
return ret;
}
return 0;
}
public:
int verify_permission(optional_yield) override {
return 0;
}
void pre_exec() override {
rgw_bucket_object_pre_exec(s);
}
void execute(optional_yield y) override;
const char* name() const override { return "pubsub_topic_delete"; }
RGWOpType get_type() override { return RGW_OP_PUBSUB_TOPIC_DELETE; }
uint32_t op_mask() override { return RGW_OP_TYPE_DELETE; }
void send_response() override {
if (op_ret) {
set_req_state_err(s, op_ret);
}
dump_errno(s);
end_header(s, this, "application/xml");
if (op_ret < 0) {
return;
}
const auto f = s->formatter;
f->open_object_section_in_ns("DeleteTopicResponse", AWS_SNS_NS);
f->open_object_section("ResponseMetadata");
encode_xml("RequestId", s->req_id, f);
f->close_section(); // ResponseMetadata
f->close_section(); // DeleteTopicResponse
rgw_flush_formatter_and_reset(s, f);
}
};
void RGWPSDeleteTopicOp::execute(optional_yield y) {
op_ret = get_params();
if (op_ret < 0) {
return;
}
const RGWPubSub ps(driver, s->owner.get_id().tenant);
op_ret = ps.remove_topic(this, topic_name, y);
if (op_ret < 0) {
ldpp_dout(this, 1) << "failed to remove topic '" << topic_name << ", ret=" << op_ret << dendl;
return;
}
ldpp_dout(this, 1) << "successfully removed topic '" << topic_name << "'" << dendl;
}
using op_generator = RGWOp*(*)();
static const std::unordered_map<std::string, op_generator> op_generators = {
{"CreateTopic", []() -> RGWOp* {return new RGWPSCreateTopicOp;}},
{"DeleteTopic", []() -> RGWOp* {return new RGWPSDeleteTopicOp;}},
{"ListTopics", []() -> RGWOp* {return new RGWPSListTopicsOp;}},
{"GetTopic", []() -> RGWOp* {return new RGWPSGetTopicOp;}},
{"GetTopicAttributes", []() -> RGWOp* {return new RGWPSGetTopicAttributesOp;}}
};
bool RGWHandler_REST_PSTopic_AWS::action_exists(const req_state* s)
{
if (s->info.args.exists("Action")) {
const std::string action_name = s->info.args.get("Action");
return op_generators.contains(action_name);
}
return false;
}
RGWOp *RGWHandler_REST_PSTopic_AWS::op_post()
{
s->dialect = "sns";
s->prot_flags = RGW_REST_STS;
if (s->info.args.exists("Action")) {
const std::string action_name = s->info.args.get("Action");
const auto action_it = op_generators.find(action_name);
if (action_it != op_generators.end()) {
return action_it->second();
}
ldpp_dout(s, 10) << "unknown action '" << action_name << "' for Topic handler" << dendl;
} else {
ldpp_dout(s, 10) << "missing action argument in Topic handler" << dendl;
}
return nullptr;
}
int RGWHandler_REST_PSTopic_AWS::authorize(const DoutPrefixProvider* dpp, optional_yield y) {
const auto rc = RGW_Auth_S3::authorize(dpp, driver, auth_registry, s, y);
if (rc < 0) {
return rc;
}
if (s->auth.identity->is_anonymous()) {
ldpp_dout(dpp, 1) << "anonymous user not allowed in topic operations" << dendl;
return -ERR_INVALID_REQUEST;
}
return 0;
}
namespace {
// return a unique topic by prefexing with the notification name: <notification>_<topic>
std::string topic_to_unique(const std::string& topic, const std::string& notification) {
return notification + "_" + topic;
}
// extract the topic from a unique topic of the form: <notification>_<topic>
[[maybe_unused]] std::string unique_to_topic(const std::string& unique_topic, const std::string& notification) {
if (unique_topic.find(notification + "_") == std::string::npos) {
return "";
}
return unique_topic.substr(notification.length() + 1);
}
// from list of bucket topics, find the one that was auto-generated by a notification
auto find_unique_topic(const rgw_pubsub_bucket_topics& bucket_topics, const std::string& notif_name) {
auto it = std::find_if(bucket_topics.topics.begin(), bucket_topics.topics.end(), [&](const auto& val) { return notif_name == val.second.s3_id; });
return it != bucket_topics.topics.end() ?
std::optional<std::reference_wrapper<const rgw_pubsub_topic_filter>>(it->second):
std::nullopt;
}
}
int remove_notification_by_topic(const DoutPrefixProvider *dpp, const std::string& topic_name, const RGWPubSub::Bucket& b, optional_yield y, const RGWPubSub& ps) {
int op_ret = b.remove_notification(dpp, topic_name, y);
if (op_ret < 0) {
ldpp_dout(dpp, 1) << "failed to remove notification of topic '" << topic_name << "', ret=" << op_ret << dendl;
}
op_ret = ps.remove_topic(dpp, topic_name, y);
if (op_ret < 0) {
ldpp_dout(dpp, 1) << "failed to remove auto-generated topic '" << topic_name << "', ret=" << op_ret << dendl;
}
return op_ret;
}
int delete_all_notifications(const DoutPrefixProvider *dpp, const rgw_pubsub_bucket_topics& bucket_topics, const RGWPubSub::Bucket& b, optional_yield y, const RGWPubSub& ps) {
// delete all notifications of on a bucket
for (const auto& topic : bucket_topics.topics) {
const auto op_ret = remove_notification_by_topic(dpp, topic.first, b, y, ps);
if (op_ret < 0) {
return op_ret;
}
}
return 0;
}
// command (S3 compliant): PUT /<bucket name>?notification
// a "notification" and a subscription will be auto-generated
// actual configuration is XML encoded in the body of the message
class RGWPSCreateNotifOp : public RGWDefaultResponseOp {
int verify_params() override {
bool exists;
const auto no_value = s->info.args.get("notification", &exists);
if (!exists) {
ldpp_dout(this, 1) << "missing required param 'notification'" << dendl;
return -EINVAL;
}
if (no_value.length() > 0) {
ldpp_dout(this, 1) << "param 'notification' should not have any value" << dendl;
return -EINVAL;
}
if (s->bucket_name.empty()) {
ldpp_dout(this, 1) << "request must be on a bucket" << dendl;
return -EINVAL;
}
return 0;
}
int get_params_from_body(rgw_pubsub_s3_notifications& configurations) {
const auto max_size = s->cct->_conf->rgw_max_put_param_size;
int r;
bufferlist data;
std::tie(r, data) = read_all_input(s, max_size, false);
if (r < 0) {
ldpp_dout(this, 1) << "failed to read XML payload" << dendl;
return r;
}
if (data.length() == 0) {
ldpp_dout(this, 1) << "XML payload missing" << dendl;
return -EINVAL;
}
RGWXMLDecoder::XMLParser parser;
if (!parser.init()){
ldpp_dout(this, 1) << "failed to initialize XML parser" << dendl;
return -EINVAL;
}
if (!parser.parse(data.c_str(), data.length(), 1)) {
ldpp_dout(this, 1) << "failed to parse XML payload" << dendl;
return -ERR_MALFORMED_XML;
}
try {
// NotificationConfigurations is mandatory
// It can be empty which means we delete all the notifications
RGWXMLDecoder::decode_xml("NotificationConfiguration", configurations, &parser, true);
} catch (RGWXMLDecoder::err& err) {
ldpp_dout(this, 1) << "failed to parse XML payload. error: " << err << dendl;
return -ERR_MALFORMED_XML;
}
return 0;
}
public:
int verify_permission(optional_yield y) override;
void pre_exec() override {
rgw_bucket_object_pre_exec(s);
}
const char* name() const override { return "pubsub_notification_create_s3"; }
RGWOpType get_type() override { return RGW_OP_PUBSUB_NOTIF_CREATE; }
uint32_t op_mask() override { return RGW_OP_TYPE_WRITE; }
void execute(optional_yield) override;
};
void RGWPSCreateNotifOp::execute(optional_yield y) {
op_ret = verify_params();
if (op_ret < 0) {
return;
}
rgw_pubsub_s3_notifications configurations;
op_ret = get_params_from_body(configurations);
if (op_ret < 0) {
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->get_bucket(this, user.get(), s->owner.get_id().tenant, s->bucket_name, &bucket, y);
if (op_ret < 0) {
ldpp_dout(this, 1) << "failed to get bucket '" << s->bucket_name << "' info, ret = " << op_ret << dendl;
return;
}
const RGWPubSub ps(driver, s->owner.get_id().tenant);
const RGWPubSub::Bucket b(ps, bucket.get());
if(configurations.list.empty()) {
// get all topics on a bucket
rgw_pubsub_bucket_topics bucket_topics;
op_ret = b.get_topics(this, bucket_topics, y);
if (op_ret < 0) {
ldpp_dout(this, 1) << "failed to get list of topics from bucket '" << s->bucket_name << "', ret=" << op_ret << dendl;
return;
}
op_ret = delete_all_notifications(this, bucket_topics, b, y, ps);
return;
}
for (const auto& c : configurations.list) {
const auto& notif_name = c.id;
if (notif_name.empty()) {
ldpp_dout(this, 1) << "missing notification id" << dendl;
op_ret = -EINVAL;
return;
}
if (c.topic_arn.empty()) {
ldpp_dout(this, 1) << "missing topic ARN in notification: '" << notif_name << "'" << dendl;
op_ret = -EINVAL;
return;
}
const auto arn = rgw::ARN::parse(c.topic_arn);
if (!arn || arn->resource.empty()) {
ldpp_dout(this, 1) << "topic ARN has invalid format: '" << c.topic_arn << "' in notification: '" << notif_name << "'" << dendl;
op_ret = -EINVAL;
return;
}
if (std::find(c.events.begin(), c.events.end(), rgw::notify::UnknownEvent) != c.events.end()) {
ldpp_dout(this, 1) << "unknown event type in notification: '" << notif_name << "'" << dendl;
op_ret = -EINVAL;
return;
}
const auto topic_name = arn->resource;
// get topic information. destination information is stored in the topic
rgw_pubsub_topic topic_info;
op_ret = ps.get_topic(this, topic_name, topic_info, y);
if (op_ret < 0) {
ldpp_dout(this, 1) << "failed to get topic '" << topic_name << "', ret=" << op_ret << dendl;
return;
}
// make sure that full topic configuration match
// TODO: use ARN match function
// create unique topic name. this has 2 reasons:
// (1) topics cannot be shared between different S3 notifications because they hold the filter information
// (2) make topic clneaup easier, when notification is removed
const auto unique_topic_name = topic_to_unique(topic_name, notif_name);
// generate the internal topic. destination is stored here for the "push-only" case
// when no subscription exists
// ARN is cached to make the "GET" method faster
op_ret = ps.create_topic(this, unique_topic_name, topic_info.dest, topic_info.arn, topic_info.opaque_data, y);
if (op_ret < 0) {
ldpp_dout(this, 1) << "failed to auto-generate unique topic '" << unique_topic_name <<
"', ret=" << op_ret << dendl;
return;
}
ldpp_dout(this, 20) << "successfully auto-generated unique topic '" << unique_topic_name << "'" << dendl;
// generate the notification
rgw::notify::EventTypeList events;
op_ret = b.create_notification(this, unique_topic_name, c.events, std::make_optional(c.filter), notif_name, y);
if (op_ret < 0) {
ldpp_dout(this, 1) << "failed to auto-generate notification for unique topic '" << unique_topic_name <<
"', ret=" << op_ret << dendl;
// rollback generated topic (ignore return value)
ps.remove_topic(this, unique_topic_name, y);
return;
}
ldpp_dout(this, 20) << "successfully auto-generated notification for unique topic '" << unique_topic_name << "'" << dendl;
}
}
int RGWPSCreateNotifOp::verify_permission(optional_yield y) {
if (!verify_bucket_permission(this, s, rgw::IAM::s3PutBucketNotification)) {
return -EACCES;
}
return 0;
}
// command (extension to S3): DELETE /bucket?notification[=<notification-id>]
class RGWPSDeleteNotifOp : public RGWDefaultResponseOp {
int get_params(std::string& notif_name) const {
bool exists;
notif_name = s->info.args.get("notification", &exists);
if (!exists) {
ldpp_dout(this, 1) << "missing required param 'notification'" << dendl;
return -EINVAL;
}
if (s->bucket_name.empty()) {
ldpp_dout(this, 1) << "request must be on a bucket" << dendl;
return -EINVAL;
}
return 0;
}
public:
int verify_permission(optional_yield y) override;
void pre_exec() override {
rgw_bucket_object_pre_exec(s);
}
const char* name() const override { return "pubsub_notification_delete_s3"; }
RGWOpType get_type() override { return RGW_OP_PUBSUB_NOTIF_DELETE; }
uint32_t op_mask() override { return RGW_OP_TYPE_DELETE; }
void execute(optional_yield y) override;
};
void RGWPSDeleteNotifOp::execute(optional_yield y) {
std::string notif_name;
op_ret = get_params(notif_name);
if (op_ret < 0) {
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->get_bucket(this, user.get(), s->owner.get_id().tenant, s->bucket_name, &bucket, y);
if (op_ret < 0) {
ldpp_dout(this, 1) << "failed to get bucket '" << s->bucket_name << "' info, ret = " << op_ret << dendl;
return;
}
const RGWPubSub ps(driver, s->owner.get_id().tenant);
const RGWPubSub::Bucket b(ps, bucket.get());
// get all topics on a bucket
rgw_pubsub_bucket_topics bucket_topics;
op_ret = b.get_topics(this, bucket_topics, y);
if (op_ret < 0) {
ldpp_dout(this, 1) << "failed to get list of topics from bucket '" << s->bucket_name << "', ret=" << op_ret << dendl;
return;
}
if (!notif_name.empty()) {
// delete a specific notification
const auto unique_topic = find_unique_topic(bucket_topics, notif_name);
if (unique_topic) {
const auto unique_topic_name = unique_topic->get().topic.name;
op_ret = remove_notification_by_topic(this, unique_topic_name, b, y, ps);
return;
}
// notification to be removed is not found - considered success
ldpp_dout(this, 20) << "notification '" << notif_name << "' already removed" << dendl;
return;
}
op_ret = delete_all_notifications(this, bucket_topics, b, y, ps);
}
int RGWPSDeleteNotifOp::verify_permission(optional_yield y) {
if (!verify_bucket_permission(this, s, rgw::IAM::s3PutBucketNotification)) {
return -EACCES;
}
return 0;
}
// command (S3 compliant): GET /bucket?notification[=<notification-id>]
class RGWPSListNotifsOp : public RGWOp {
rgw_pubsub_s3_notifications notifications;
int get_params(std::string& notif_name) const {
bool exists;
notif_name = s->info.args.get("notification", &exists);
if (!exists) {
ldpp_dout(this, 1) << "missing required param 'notification'" << dendl;
return -EINVAL;
}
if (s->bucket_name.empty()) {
ldpp_dout(this, 1) << "request must be on a bucket" << dendl;
return -EINVAL;
}
return 0;
}
public:
int verify_permission(optional_yield y) override;
void pre_exec() override {
rgw_bucket_object_pre_exec(s);
}
const char* name() const override { return "pubsub_notifications_get_s3"; }
RGWOpType get_type() override { return RGW_OP_PUBSUB_NOTIF_LIST; }
uint32_t op_mask() override { return RGW_OP_TYPE_READ; }
void execute(optional_yield y) override;
void send_response() override {
if (op_ret) {
set_req_state_err(s, op_ret);
}
dump_errno(s);
end_header(s, this, "application/xml");
if (op_ret < 0) {
return;
}
notifications.dump_xml(s->formatter);
rgw_flush_formatter_and_reset(s, s->formatter);
}
};
void RGWPSListNotifsOp::execute(optional_yield y) {
std::string notif_name;
op_ret = get_params(notif_name);
if (op_ret < 0) {
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->get_bucket(this, user.get(), s->owner.get_id().tenant, s->bucket_name, &bucket, y);
if (op_ret < 0) {
ldpp_dout(this, 1) << "failed to get bucket '" << s->bucket_name << "' info, ret = " << op_ret << dendl;
return;
}
const RGWPubSub ps(driver, s->owner.get_id().tenant);
const RGWPubSub::Bucket b(ps, bucket.get());
// get all topics on a bucket
rgw_pubsub_bucket_topics bucket_topics;
op_ret = b.get_topics(this, bucket_topics, y);
if (op_ret < 0) {
ldpp_dout(this, 1) << "failed to get list of topics from bucket '" << s->bucket_name << "', ret=" << op_ret << dendl;
return;
}
if (!notif_name.empty()) {
// get info of a specific notification
const auto unique_topic = find_unique_topic(bucket_topics, notif_name);
if (unique_topic) {
notifications.list.emplace_back(unique_topic->get());
return;
}
op_ret = -ENOENT;
ldpp_dout(this, 1) << "failed to get notification info for '" << notif_name << "', ret=" << op_ret << dendl;
return;
}
// loop through all topics of the bucket
for (const auto& topic : bucket_topics.topics) {
if (topic.second.s3_id.empty()) {
// not an s3 notification
continue;
}
notifications.list.emplace_back(topic.second);
}
}
int RGWPSListNotifsOp::verify_permission(optional_yield y) {
if (!verify_bucket_permission(this, s, rgw::IAM::s3GetBucketNotification)) {
return -EACCES;
}
return 0;
}
RGWOp* RGWHandler_REST_PSNotifs_S3::op_get() {
return new RGWPSListNotifsOp();
}
RGWOp* RGWHandler_REST_PSNotifs_S3::op_put() {
return new RGWPSCreateNotifOp();
}
RGWOp* RGWHandler_REST_PSNotifs_S3::op_delete() {
return new RGWPSDeleteNotifOp();
}
RGWOp* RGWHandler_REST_PSNotifs_S3::create_get_op() {
return new RGWPSListNotifsOp();
}
RGWOp* RGWHandler_REST_PSNotifs_S3::create_put_op() {
return new RGWPSCreateNotifOp();
}
RGWOp* RGWHandler_REST_PSNotifs_S3::create_delete_op() {
return new RGWPSDeleteNotifOp();
}
| 30,757 | 31.410959 | 175 |
cc
|
null |
ceph-main/src/rgw/rgw_rest_ratelimit.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#include "rgw_rest_ratelimit.h"
class RGWOp_Ratelimit_Info : public RGWRESTOp {
int check_caps(const RGWUserCaps& caps) override {
return caps.check_cap("ratelimit", RGW_CAP_READ);
}
void execute(optional_yield y) override;
const char* name() const override { return "get_ratelimit_info"; }
};
void RGWOp_Ratelimit_Info::execute(optional_yield y)
{
ldpp_dout(this, 20) << "" << dendl;
std::string uid_str;
std::string ratelimit_scope;
std::string bucket_name;
std::string tenant_name;
bool global = false;
RESTArgs::get_string(s, "uid", uid_str, &uid_str);
RESTArgs::get_string(s, "ratelimit-scope", ratelimit_scope, &ratelimit_scope);
RESTArgs::get_string(s, "bucket", bucket_name, &bucket_name);
RESTArgs::get_string(s, "tenant", tenant_name, &tenant_name);
// RESTArgs::get_bool default value to true even if global is empty
bool exists;
std::string sval = s->info.args.get("global", &exists);
if (exists) {
if (!boost::iequals(sval,"true") && !boost::iequals(sval,"false")) {
op_ret = -EINVAL;
ldpp_dout(this, 20) << "global is not equal to true or false" << dendl;
return;
}
}
RESTArgs::get_bool(s, "global", false, &global);
if (ratelimit_scope == "bucket" && !bucket_name.empty() && !global) {
std::unique_ptr<rgw::sal::Bucket> bucket;
int r = driver->get_bucket(s, nullptr, tenant_name, bucket_name, &bucket, y);
if (r != 0) {
op_ret = r;
ldpp_dout(this, 0) << "Error on getting bucket info" << dendl;
return;
}
RGWRateLimitInfo ratelimit_info;
auto iter = bucket->get_attrs().find(RGW_ATTR_RATELIMIT);
if (iter != bucket->get_attrs().end()) {
try {
bufferlist& bl = iter->second;
auto biter = bl.cbegin();
decode(ratelimit_info, biter);
} catch (buffer::error& err) {
ldpp_dout(this, 0) << "Error on decoding ratelimit info from bucket" << dendl;
op_ret = -EIO;
return;
}
}
flusher.start(0);
s->formatter->open_object_section("bucket_ratelimit");
encode_json("bucket_ratelimit", ratelimit_info, s->formatter);
s->formatter->close_section();
flusher.flush();
return;
}
if (ratelimit_scope == "user" && !uid_str.empty() && !global) {
RGWRateLimitInfo ratelimit_info;
rgw_user user(uid_str);
std::unique_ptr<rgw::sal::User> user_sal;
user_sal = driver->get_user(user);
if (!rgw::sal::User::empty(user_sal)) {
op_ret = user_sal->load_user(this, y);
if (op_ret) {
ldpp_dout(this, 0) << "Cannot load user info" << dendl;
return;
}
} else {
ldpp_dout(this, 0) << "User does not exist" << dendl;
op_ret = -ENOENT;
return;
}
auto iter = user_sal->get_attrs().find(RGW_ATTR_RATELIMIT);
if(iter != user_sal->get_attrs().end()) {
try {
bufferlist& bl = iter->second;
auto biter = bl.cbegin();
decode(ratelimit_info, biter);
} catch (buffer::error& err) {
ldpp_dout(this, 0) << "Error on decoding ratelimit info from user" << dendl;
op_ret = -EIO;
return;
}
}
flusher.start(0);
s->formatter->open_object_section("user_ratelimit");
encode_json("user_ratelimit", ratelimit_info, s->formatter);
s->formatter->close_section();
flusher.flush();
}
if (global) {
std::string realm_id = driver->get_zone()->get_realm_id();
RGWPeriodConfig period_config;
op_ret = period_config.read(this, static_cast<rgw::sal::RadosStore*>(driver)->svc()->sysobj, realm_id, y);
if (op_ret && op_ret != -ENOENT) {
ldpp_dout(this, 0) << "Error on period config read" << dendl;
return;
}
flusher.start(0);
s->formatter->open_object_section("period_config");
encode_json("bucket_ratelimit", period_config.bucket_ratelimit, s->formatter);
encode_json("user_ratelimit", period_config.user_ratelimit, s->formatter);
encode_json("anonymous_ratelimit", period_config.anon_ratelimit, s->formatter);
s->formatter->close_section();
flusher.flush();
return;
}
op_ret = -EINVAL;
return;
}
class RGWOp_Ratelimit_Set : public RGWRESTOp {
int check_caps(const RGWUserCaps& caps) override {
return caps.check_cap("ratelimit", RGW_CAP_WRITE);
}
void execute(optional_yield y) override;
const char* name() const override { return "put_ratelimit_info"; }
void set_ratelimit_info(bool have_max_read_ops, int64_t max_read_ops, bool have_max_write_ops, int64_t max_write_ops,
bool have_max_read_bytes, int64_t max_read_bytes, bool have_max_write_bytes, int64_t max_write_bytes,
bool have_enabled, bool enabled, bool& ratelimit_configured, RGWRateLimitInfo& ratelimit_info);
};
void RGWOp_Ratelimit_Set::set_ratelimit_info(bool have_max_read_ops, int64_t max_read_ops, bool have_max_write_ops, int64_t max_write_ops,
bool have_max_read_bytes, int64_t max_read_bytes, bool have_max_write_bytes, int64_t max_write_bytes,
bool have_enabled, bool enabled, bool& ratelimit_configured, RGWRateLimitInfo& ratelimit_info)
{
if (have_max_read_ops) {
if (max_read_ops >= 0) {
ratelimit_info.max_read_ops = max_read_ops;
ratelimit_configured = true;
}
}
if (have_max_write_ops) {
if (max_write_ops >= 0) {
ratelimit_info.max_write_ops = max_write_ops;
ratelimit_configured = true;
}
}
if (have_max_read_bytes) {
if (max_read_bytes >= 0) {
ratelimit_info.max_read_bytes = max_read_bytes;
ratelimit_configured = true;
}
}
if (have_max_write_bytes) {
if (max_write_bytes >= 0) {
ratelimit_info.max_write_bytes = max_write_bytes;
ratelimit_configured = true;
}
}
if (have_enabled) {
ratelimit_info.enabled = enabled;
ratelimit_configured = true;
}
if (!ratelimit_configured) {
ldpp_dout(this, 0) << "No rate limit configuration arguments have been sent" << dendl;
op_ret = -EINVAL;
return;
}
}
void RGWOp_Ratelimit_Set::execute(optional_yield y)
{
std::string uid_str;
std::string ratelimit_scope;
std::string bucket_name;
std::string tenant_name;
RGWRateLimitInfo ratelimit_info;
bool ratelimit_configured = false;
bool enabled = false;
bool have_enabled = false;
bool global = false;
int64_t max_read_ops = 0;
bool have_max_read_ops = false;
int64_t max_write_ops = 0;
bool have_max_write_ops = false;
int64_t max_read_bytes = 0;
bool have_max_read_bytes = false;
int64_t max_write_bytes = 0;
bool have_max_write_bytes = false;
RESTArgs::get_string(s, "uid", uid_str, &uid_str);
RESTArgs::get_string(s, "ratelimit-scope", ratelimit_scope, &ratelimit_scope);
RESTArgs::get_string(s, "bucket", bucket_name, &bucket_name);
RESTArgs::get_string(s, "tenant", tenant_name, &tenant_name);
// check there was no -EINVAL coming from get_int64
op_ret = RESTArgs::get_int64(s, "max-read-ops", 0, &max_read_ops, &have_max_read_ops);
op_ret |= RESTArgs::get_int64(s, "max-write-ops", 0, &max_write_ops, &have_max_write_ops);
op_ret |= RESTArgs::get_int64(s, "max-read-bytes", 0, &max_read_bytes, &have_max_read_bytes);
op_ret |= RESTArgs::get_int64(s, "max-write-bytes", 0, &max_write_bytes, &have_max_write_bytes);
if (op_ret) {
ldpp_dout(this, 0) << "one of the maximum arguments could not be parsed" << dendl;
return;
}
// RESTArgs::get_bool default value to true even if enabled or global are empty
std::string sval = s->info.args.get("enabled", &have_enabled);
if (have_enabled) {
if (!boost::iequals(sval,"true") && !boost::iequals(sval,"false")) {
ldpp_dout(this, 20) << "enabled is not equal to true or false" << dendl;
op_ret = -EINVAL;
return;
}
}
RESTArgs::get_bool(s, "enabled", false, &enabled, &have_enabled);
bool exists;
sval = s->info.args.get("global", &exists);
if (exists) {
if (!boost::iequals(sval,"true") && !boost::iequals(sval,"false")) {
ldpp_dout(this, 20) << "global is not equal to true or faslse" << dendl;
op_ret = -EINVAL;
return;
}
}
RESTArgs::get_bool(s, "global", false, &global, nullptr);
set_ratelimit_info(have_max_read_ops, max_read_ops, have_max_write_ops, max_write_ops,
have_max_read_bytes, max_read_bytes, have_max_write_bytes, max_write_bytes,
have_enabled, enabled, ratelimit_configured, ratelimit_info);
if (op_ret) {
return;
}
if (ratelimit_scope == "user" && !uid_str.empty() && !global) {
rgw_user user(uid_str);
std::unique_ptr<rgw::sal::User> user_sal;
user_sal = driver->get_user(user);
if (!rgw::sal::User::empty(user_sal)) {
op_ret = user_sal->load_user(this, y);
if (op_ret) {
ldpp_dout(this, 0) << "Cannot load user info" << dendl;
return;
}
} else {
ldpp_dout(this, 0) << "User does not exist" << dendl;
op_ret = -ENOENT;
return;
}
auto iter = user_sal->get_attrs().find(RGW_ATTR_RATELIMIT);
if (iter != user_sal->get_attrs().end()) {
try {
bufferlist& bl = iter->second;
auto biter = bl.cbegin();
decode(ratelimit_info, biter);
} catch (buffer::error& err) {
ldpp_dout(this, 0) << "Error on decoding ratelimit info from user" << dendl;
op_ret = -EIO;
return;
}
}
set_ratelimit_info(have_max_read_ops, max_read_ops, have_max_write_ops, max_write_ops,
have_max_read_bytes, max_read_bytes, have_max_write_bytes, max_write_bytes,
have_enabled, enabled, ratelimit_configured, ratelimit_info);
bufferlist bl;
ratelimit_info.encode(bl);
rgw::sal::Attrs attr;
attr[RGW_ATTR_RATELIMIT] = bl;
op_ret = user_sal->merge_and_store_attrs(this, attr, y);
return;
}
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->get_bucket(this, nullptr, tenant_name, bucket_name, &bucket, y);
if (op_ret) {
ldpp_dout(this, 0) << "Error on getting bucket info" << dendl;
return;
}
auto iter = bucket->get_attrs().find(RGW_ATTR_RATELIMIT);
if (iter != bucket->get_attrs().end()) {
try {
bufferlist& bl = iter->second;
auto biter = bl.cbegin();
decode(ratelimit_info, biter);
} catch (buffer::error& err) {
ldpp_dout(this, 0) << "Error on decoding ratelimit info from bucket" << dendl;
op_ret = -EIO;
return;
}
}
bufferlist bl;
set_ratelimit_info(have_max_read_ops, max_read_ops, have_max_write_ops, max_write_ops,
have_max_read_bytes, max_read_bytes, have_max_write_bytes, max_write_bytes,
have_enabled, enabled, ratelimit_configured, ratelimit_info);
ratelimit_info.encode(bl);
rgw::sal::Attrs attr;
attr[RGW_ATTR_RATELIMIT] = bl;
op_ret = bucket->merge_and_store_attrs(this, attr, y);
return;
}
if (global) {
std::string realm_id = driver->get_zone()->get_realm_id();
RGWPeriodConfig period_config;
op_ret = period_config.read(s, static_cast<rgw::sal::RadosStore*>(driver)->svc()->sysobj, realm_id, y);
if (op_ret && op_ret != -ENOENT) {
ldpp_dout(this, 0) << "Error on period config read" << dendl;
return;
}
if (ratelimit_scope == "bucket") {
ratelimit_info = period_config.bucket_ratelimit;
set_ratelimit_info(have_max_read_ops, max_read_ops, have_max_write_ops, max_write_ops,
have_max_read_bytes, max_read_bytes, have_max_write_bytes, max_write_bytes,
have_enabled, enabled, ratelimit_configured, ratelimit_info);
period_config.bucket_ratelimit = ratelimit_info;
op_ret = period_config.write(s, static_cast<rgw::sal::RadosStore*>(driver)->svc()->sysobj, realm_id, y);
return;
}
if (ratelimit_scope == "anon") {
ratelimit_info = period_config.anon_ratelimit;
set_ratelimit_info(have_max_read_ops, max_read_ops, have_max_write_ops, max_write_ops,
have_max_read_bytes, max_read_bytes, have_max_write_bytes, max_write_bytes,
have_enabled, enabled, ratelimit_configured, ratelimit_info);
period_config.anon_ratelimit = ratelimit_info;
op_ret = period_config.write(s, static_cast<rgw::sal::RadosStore*>(driver)->svc()->sysobj, realm_id, y);
return;
}
if (ratelimit_scope == "user") {
ratelimit_info = period_config.user_ratelimit;
set_ratelimit_info(have_max_read_ops, max_read_ops, have_max_write_ops, max_write_ops,
have_max_read_bytes, max_read_bytes, have_max_write_bytes, max_write_bytes,
have_enabled, enabled, ratelimit_configured, ratelimit_info);
period_config.user_ratelimit = ratelimit_info;
op_ret = period_config.write(s, static_cast<rgw::sal::RadosStore*>(driver)->svc()->sysobj, realm_id, y);
return;
}
}
op_ret = -EINVAL;
return;
}
RGWOp* RGWHandler_Ratelimit::op_get()
{
return new RGWOp_Ratelimit_Info;
}
RGWOp* RGWHandler_Ratelimit::op_post()
{
return new RGWOp_Ratelimit_Set;
}
| 13,494 | 37.557143 | 140 |
cc
|
null |
ceph-main/src/rgw/rgw_rest_ratelimit.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#pragma once
#include "rgw_rest.h"
#include "rgw_rest_s3.h"
#include "rgw_sal_rados.h"
class RGWHandler_Ratelimit : public RGWHandler_Auth_S3 {
protected:
RGWOp *op_get() override;
RGWOp *op_post() override;
public:
using RGWHandler_Auth_S3::RGWHandler_Auth_S3;
~RGWHandler_Ratelimit() override = default;
int read_permissions(RGWOp*, optional_yield) override {
return 0;
}
};
class RGWRESTMgr_Ratelimit : public RGWRESTMgr {
public:
RGWRESTMgr_Ratelimit() = default;
~RGWRESTMgr_Ratelimit() override = default;
RGWHandler_REST *get_handler(rgw::sal::Driver* driver,
req_state*,
const rgw::auth::StrategyRegistry& auth_registry,
const std::string&) override {
return new RGWHandler_Ratelimit(auth_registry);
}
};
| 924 | 25.428571 | 80 |
h
|
null |
ceph-main/src/rgw/rgw_rest_role.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#include <errno.h>
#include <regex>
#include "common/errno.h"
#include "common/Formatter.h"
#include "common/ceph_json.h"
#include "include/types.h"
#include "rgw_string.h"
#include "rgw_common.h"
#include "rgw_op.h"
#include "rgw_rest.h"
#include "rgw_role.h"
#include "rgw_rest_role.h"
#include "rgw_sal.h"
#define dout_subsys ceph_subsys_rgw
using namespace std;
int RGWRestRole::verify_permission(optional_yield y)
{
if (s->auth.identity->is_anonymous()) {
return -EACCES;
}
string role_name = s->info.args.get("RoleName");
std::unique_ptr<rgw::sal::RGWRole> role = driver->get_role(role_name,
s->user->get_tenant());
if (op_ret = role->get(s, y); op_ret < 0) {
if (op_ret == -ENOENT) {
op_ret = -ERR_NO_ROLE_FOUND;
}
return op_ret;
}
if (int ret = check_caps(s->user->get_caps()); ret == 0) {
_role = std::move(role);
return ret;
}
string resource_name = role->get_path() + role_name;
uint64_t op = get_op();
if (!verify_user_permission(this,
s,
rgw::ARN(resource_name,
"role",
s->user->get_tenant(), true),
op)) {
return -EACCES;
}
_role = std::move(role);
return 0;
}
int RGWRestRole::parse_tags()
{
vector<string> keys, vals;
auto val_map = s->info.args.get_params();
const regex pattern_key("Tags.member.([0-9]+).Key");
const regex pattern_value("Tags.member.([0-9]+).Value");
for (auto& v : val_map) {
string key_index="", value_index="";
for(sregex_iterator it = sregex_iterator(
v.first.begin(), v.first.end(), pattern_key);
it != sregex_iterator(); it++) {
smatch match;
match = *it;
key_index = match.str(1);
ldout(s->cct, 20) << "Key index: " << match.str(1) << dendl;
if (!key_index.empty()) {
int index = stoi(key_index);
auto pos = keys.begin() + (index-1);
keys.insert(pos, v.second);
}
}
for(sregex_iterator it = sregex_iterator(
v.first.begin(), v.first.end(), pattern_value);
it != sregex_iterator(); it++) {
smatch match;
match = *it;
value_index = match.str(1);
ldout(s->cct, 20) << "Value index: " << match.str(1) << dendl;
if (!value_index.empty()) {
int index = stoi(value_index);
auto pos = vals.begin() + (index-1);
vals.insert(pos, v.second);
}
}
}
if (keys.size() != vals.size()) {
ldout(s->cct, 0) << "No. of keys doesn't match with no. of values in tags" << dendl;
return -EINVAL;
}
for (size_t i = 0; i < keys.size(); i++) {
tags.emplace(keys[i], vals[i]);
ldout(s->cct, 0) << "Tag Key: " << keys[i] << " Tag Value is: " << vals[i] << dendl;
}
return 0;
}
void RGWRestRole::send_response()
{
if (op_ret) {
set_req_state_err(s, op_ret);
}
dump_errno(s);
end_header(s, this);
}
int RGWRoleRead::check_caps(const RGWUserCaps& caps)
{
return caps.check_cap("roles", RGW_CAP_READ);
}
int RGWRoleWrite::check_caps(const RGWUserCaps& caps)
{
return caps.check_cap("roles", RGW_CAP_WRITE);
}
int RGWCreateRole::verify_permission(optional_yield y)
{
if (s->auth.identity->is_anonymous()) {
return -EACCES;
}
if (int ret = check_caps(s->user->get_caps()); ret == 0) {
return ret;
}
string role_name = s->info.args.get("RoleName");
string role_path = s->info.args.get("Path");
string resource_name = role_path + role_name;
if (!verify_user_permission(this,
s,
rgw::ARN(resource_name,
"role",
s->user->get_tenant(), true),
get_op())) {
return -EACCES;
}
return 0;
}
int RGWCreateRole::get_params()
{
role_name = s->info.args.get("RoleName");
role_path = s->info.args.get("Path");
trust_policy = s->info.args.get("AssumeRolePolicyDocument");
max_session_duration = s->info.args.get("MaxSessionDuration");
if (role_name.empty() || trust_policy.empty()) {
ldpp_dout(this, 20) << "ERROR: one of role name or assume role policy document is empty"
<< dendl;
return -EINVAL;
}
bufferlist bl = bufferlist::static_from_string(trust_policy);
try {
const rgw::IAM::Policy p(
s->cct, s->user->get_tenant(), bl,
s->cct->_conf.get_val<bool>("rgw_policy_reject_invalid_principals"));
}
catch (rgw::IAM::PolicyParseException& e) {
ldpp_dout(this, 5) << "failed to parse policy: " << e.what() << dendl;
s->err.message = e.what();
return -ERR_MALFORMED_DOC;
}
int ret = parse_tags();
if (ret < 0) {
return ret;
}
if (tags.size() > 50) {
ldout(s->cct, 0) << "No. tags is greater than 50" << dendl;
return -EINVAL;
}
return 0;
}
void RGWCreateRole::execute(optional_yield y)
{
op_ret = get_params();
if (op_ret < 0) {
return;
}
std::string user_tenant = s->user->get_tenant();
std::unique_ptr<rgw::sal::RGWRole> role = driver->get_role(role_name,
user_tenant,
role_path,
trust_policy,
max_session_duration,
tags);
if (!user_tenant.empty() && role->get_tenant() != user_tenant) {
ldpp_dout(this, 20) << "ERROR: the tenant provided in the role name does not match with the tenant of the user creating the role"
<< dendl;
op_ret = -EINVAL;
return;
}
std::string role_id;
if (!driver->is_meta_master()) {
RGWXMLDecoder::XMLParser parser;
if (!parser.init()) {
ldpp_dout(this, 0) << "ERROR: failed to initialize xml parser" << dendl;
op_ret = -EINVAL;
return;
}
bufferlist data;
s->info.args.remove("RoleName");
s->info.args.remove("Path");
s->info.args.remove("AssumeRolePolicyDocument");
s->info.args.remove("MaxSessionDuration");
s->info.args.remove("Action");
s->info.args.remove("Version");
auto& val_map = s->info.args.get_params();
for (auto it = val_map.begin(); it!= val_map.end(); it++) {
if (it->first.find("Tags.member.") == 0) {
val_map.erase(it);
}
}
RGWUserInfo info = s->user->get_info();
const auto& it = info.access_keys.begin();
RGWAccessKey key;
if (it != info.access_keys.end()) {
key.id = it->first;
RGWAccessKey cred = it->second;
key.key = cred.key;
}
op_ret = driver->forward_iam_request_to_master(s, key, nullptr, bl_post_body, &parser, s->info, y);
if (op_ret < 0) {
ldpp_dout(this, 20) << "ERROR: forward_iam_request_to_master failed with error code: " << op_ret << dendl;
return;
}
XMLObj* create_role_resp_obj = parser.find_first("CreateRoleResponse");;
if (!create_role_resp_obj) {
ldpp_dout(this, 5) << "ERROR: unexpected xml: CreateRoleResponse" << dendl;
op_ret = -EINVAL;
return;
}
XMLObj* create_role_res_obj = create_role_resp_obj->find_first("CreateRoleResult");
if (!create_role_res_obj) {
ldpp_dout(this, 5) << "ERROR: unexpected xml: CreateRoleResult" << dendl;
op_ret = -EINVAL;
return;
}
XMLObj* role_obj = nullptr;
if (create_role_res_obj) {
role_obj = create_role_res_obj->find_first("Role");
}
if (!role_obj) {
ldpp_dout(this, 5) << "ERROR: unexpected xml: Role" << dendl;
op_ret = -EINVAL;
return;
}
try {
if (role_obj) {
RGWXMLDecoder::decode_xml("RoleId", role_id, role_obj, true);
}
} catch (RGWXMLDecoder::err& err) {
ldpp_dout(this, 5) << "ERROR: unexpected xml: RoleId" << dendl;
op_ret = -EINVAL;
return;
}
ldpp_dout(this, 0) << "role_id decoded from master zonegroup response is" << role_id << dendl;
}
op_ret = role->create(s, true, role_id, y);
if (op_ret == -EEXIST) {
op_ret = -ERR_ROLE_EXISTS;
return;
}
if (op_ret == 0) {
s->formatter->open_object_section("CreateRoleResponse");
s->formatter->open_object_section("CreateRoleResult");
s->formatter->open_object_section("Role");
role->dump(s->formatter);
s->formatter->close_section();
s->formatter->close_section();
s->formatter->open_object_section("ResponseMetadata");
s->formatter->dump_string("RequestId", s->trans_id);
s->formatter->close_section();
s->formatter->close_section();
}
}
int RGWDeleteRole::get_params()
{
role_name = s->info.args.get("RoleName");
if (role_name.empty()) {
ldpp_dout(this, 20) << "ERROR: Role name is empty"<< dendl;
return -EINVAL;
}
return 0;
}
void RGWDeleteRole::execute(optional_yield y)
{
bool is_master = true;
int master_op_ret = 0;
op_ret = get_params();
if (op_ret < 0) {
return;
}
if (!driver->is_meta_master()) {
is_master = false;
RGWXMLDecoder::XMLParser parser;
if (!parser.init()) {
ldpp_dout(this, 0) << "ERROR: failed to initialize xml parser" << dendl;
op_ret = -EINVAL;
}
bufferlist data;
s->info.args.remove("RoleName");
s->info.args.remove("Action");
s->info.args.remove("Version");
RGWUserInfo info = s->user->get_info();
const auto& it = info.access_keys.begin();
RGWAccessKey key;
if (it != info.access_keys.end()) {
key.id = it->first;
RGWAccessKey cred = it->second;
key.key = cred.key;
}
master_op_ret = driver->forward_iam_request_to_master(s, key, nullptr, bl_post_body, &parser, s->info, y);
if (master_op_ret < 0) {
op_ret = master_op_ret;
ldpp_dout(this, 0) << "forward_iam_request_to_master returned ret=" << op_ret << dendl;
return;
}
}
op_ret = _role->delete_obj(s, y);
if (op_ret == -ENOENT) {
//Role has been deleted since metadata from master has synced up
if (!is_master && master_op_ret == 0) {
op_ret = 0;
} else {
op_ret = -ERR_NO_ROLE_FOUND;
}
return;
}
if (!op_ret) {
s->formatter->open_object_section("DeleteRoleResponse");
s->formatter->open_object_section("ResponseMetadata");
s->formatter->dump_string("RequestId", s->trans_id);
s->formatter->close_section();
s->formatter->close_section();
}
}
int RGWGetRole::verify_permission(optional_yield y)
{
return 0;
}
int RGWGetRole::_verify_permission(const rgw::sal::RGWRole* role)
{
if (s->auth.identity->is_anonymous()) {
return -EACCES;
}
if (int ret = check_caps(s->user->get_caps()); ret == 0) {
return ret;
}
string resource_name = role->get_path() + role->get_name();
if (!verify_user_permission(this,
s,
rgw::ARN(resource_name,
"role",
s->user->get_tenant(), true),
get_op())) {
return -EACCES;
}
return 0;
}
int RGWGetRole::get_params()
{
role_name = s->info.args.get("RoleName");
if (role_name.empty()) {
ldpp_dout(this, 20) << "ERROR: Role name is empty"<< dendl;
return -EINVAL;
}
return 0;
}
void RGWGetRole::execute(optional_yield y)
{
op_ret = get_params();
if (op_ret < 0) {
return;
}
std::unique_ptr<rgw::sal::RGWRole> role = driver->get_role(role_name,
s->user->get_tenant());
op_ret = role->get(s, y);
if (op_ret == -ENOENT) {
op_ret = -ERR_NO_ROLE_FOUND;
return;
}
op_ret = _verify_permission(role.get());
if (op_ret == 0) {
s->formatter->open_object_section("GetRoleResponse");
s->formatter->open_object_section("ResponseMetadata");
s->formatter->dump_string("RequestId", s->trans_id);
s->formatter->close_section();
s->formatter->open_object_section("GetRoleResult");
s->formatter->open_object_section("Role");
role->dump(s->formatter);
s->formatter->close_section();
s->formatter->close_section();
s->formatter->close_section();
}
}
int RGWModifyRoleTrustPolicy::get_params()
{
role_name = s->info.args.get("RoleName");
trust_policy = s->info.args.get("PolicyDocument");
if (role_name.empty() || trust_policy.empty()) {
ldpp_dout(this, 20) << "ERROR: One of role name or trust policy is empty"<< dendl;
return -EINVAL;
}
JSONParser p;
if (!p.parse(trust_policy.c_str(), trust_policy.length())) {
ldpp_dout(this, 20) << "ERROR: failed to parse assume role policy doc" << dendl;
return -ERR_MALFORMED_DOC;
}
return 0;
}
void RGWModifyRoleTrustPolicy::execute(optional_yield y)
{
op_ret = get_params();
if (op_ret < 0) {
return;
}
if (!driver->is_meta_master()) {
RGWXMLDecoder::XMLParser parser;
if (!parser.init()) {
ldpp_dout(this, 0) << "ERROR: failed to initialize xml parser" << dendl;
op_ret = -EINVAL;
return;
}
bufferlist data;
s->info.args.remove("RoleName");
s->info.args.remove("PolicyDocument");
s->info.args.remove("Action");
s->info.args.remove("Version");
RGWUserInfo info = s->user->get_info();
const auto& it = info.access_keys.begin();
RGWAccessKey key;
if (it != info.access_keys.end()) {
key.id = it->first;
RGWAccessKey cred = it->second;
key.key = cred.key;
}
op_ret = driver->forward_iam_request_to_master(s, key, nullptr, bl_post_body, &parser, s->info, y);
if (op_ret < 0) {
ldpp_dout(this, 20) << "ERROR: forward_iam_request_to_master failed with error code: " << op_ret << dendl;
return;
}
}
_role->update_trust_policy(trust_policy);
op_ret = _role->update(this, y);
s->formatter->open_object_section("UpdateAssumeRolePolicyResponse");
s->formatter->open_object_section("ResponseMetadata");
s->formatter->dump_string("RequestId", s->trans_id);
s->formatter->close_section();
s->formatter->close_section();
}
int RGWListRoles::verify_permission(optional_yield y)
{
if (s->auth.identity->is_anonymous()) {
return -EACCES;
}
if (int ret = check_caps(s->user->get_caps()); ret == 0) {
return ret;
}
if (!verify_user_permission(this,
s,
rgw::ARN(),
get_op())) {
return -EACCES;
}
return 0;
}
int RGWListRoles::get_params()
{
path_prefix = s->info.args.get("PathPrefix");
return 0;
}
void RGWListRoles::execute(optional_yield y)
{
op_ret = get_params();
if (op_ret < 0) {
return;
}
vector<std::unique_ptr<rgw::sal::RGWRole>> result;
op_ret = driver->get_roles(s, y, path_prefix, s->user->get_tenant(), result);
if (op_ret == 0) {
s->formatter->open_array_section("ListRolesResponse");
s->formatter->open_array_section("ListRolesResult");
s->formatter->open_object_section("Roles");
for (const auto& it : result) {
s->formatter->open_object_section("member");
it->dump(s->formatter);
s->formatter->close_section();
}
s->formatter->close_section();
s->formatter->close_section();
s->formatter->open_object_section("ResponseMetadata");
s->formatter->dump_string("RequestId", s->trans_id);
s->formatter->close_section();
s->formatter->close_section();
}
}
int RGWPutRolePolicy::get_params()
{
role_name = s->info.args.get("RoleName");
policy_name = s->info.args.get("PolicyName");
perm_policy = s->info.args.get("PolicyDocument");
if (role_name.empty() || policy_name.empty() || perm_policy.empty()) {
ldpp_dout(this, 20) << "ERROR: One of role name, policy name or perm policy is empty"<< dendl;
return -EINVAL;
}
bufferlist bl = bufferlist::static_from_string(perm_policy);
try {
const rgw::IAM::Policy p(
s->cct, s->user->get_tenant(), bl,
s->cct->_conf.get_val<bool>("rgw_policy_reject_invalid_principals"));
}
catch (rgw::IAM::PolicyParseException& e) {
ldpp_dout(this, 20) << "failed to parse policy: " << e.what() << dendl;
s->err.message = e.what();
return -ERR_MALFORMED_DOC;
}
return 0;
}
void RGWPutRolePolicy::execute(optional_yield y)
{
op_ret = get_params();
if (op_ret < 0) {
return;
}
if (!driver->is_meta_master()) {
RGWXMLDecoder::XMLParser parser;
if (!parser.init()) {
ldpp_dout(this, 0) << "ERROR: failed to initialize xml parser" << dendl;
op_ret = -EINVAL;
return;
}
bufferlist data;
s->info.args.remove("RoleName");
s->info.args.remove("PolicyName");
s->info.args.remove("PolicyDocument");
s->info.args.remove("Action");
s->info.args.remove("Version");
RGWUserInfo info = s->user->get_info();
const auto& it = info.access_keys.begin();
RGWAccessKey key;
if (it != info.access_keys.end()) {
key.id = it->first;
RGWAccessKey cred = it->second;
key.key = cred.key;
}
op_ret = driver->forward_iam_request_to_master(s, key, nullptr, bl_post_body, &parser, s->info, y);
if (op_ret < 0) {
ldpp_dout(this, 20) << "ERROR: forward_iam_request_to_master failed with error code: " << op_ret << dendl;
return;
}
}
_role->set_perm_policy(policy_name, perm_policy);
op_ret = _role->update(this, y);
if (op_ret == 0) {
s->formatter->open_object_section("PutRolePolicyResponse");
s->formatter->open_object_section("ResponseMetadata");
s->formatter->dump_string("RequestId", s->trans_id);
s->formatter->close_section();
s->formatter->close_section();
}
}
int RGWGetRolePolicy::get_params()
{
role_name = s->info.args.get("RoleName");
policy_name = s->info.args.get("PolicyName");
if (role_name.empty() || policy_name.empty()) {
ldpp_dout(this, 20) << "ERROR: One of role name or policy name is empty"<< dendl;
return -EINVAL;
}
return 0;
}
void RGWGetRolePolicy::execute(optional_yield y)
{
op_ret = get_params();
if (op_ret < 0) {
return;
}
string perm_policy;
op_ret = _role->get_role_policy(this, policy_name, perm_policy);
if (op_ret == -ENOENT) {
op_ret = -ERR_NO_SUCH_ENTITY;
}
if (op_ret == 0) {
s->formatter->open_object_section("GetRolePolicyResponse");
s->formatter->open_object_section("ResponseMetadata");
s->formatter->dump_string("RequestId", s->trans_id);
s->formatter->close_section();
s->formatter->open_object_section("GetRolePolicyResult");
s->formatter->dump_string("PolicyName", policy_name);
s->formatter->dump_string("RoleName", role_name);
s->formatter->dump_string("PolicyDocument", perm_policy);
s->formatter->close_section();
s->formatter->close_section();
}
}
int RGWListRolePolicies::get_params()
{
role_name = s->info.args.get("RoleName");
if (role_name.empty()) {
ldpp_dout(this, 20) << "ERROR: Role name is empty"<< dendl;
return -EINVAL;
}
return 0;
}
void RGWListRolePolicies::execute(optional_yield y)
{
op_ret = get_params();
if (op_ret < 0) {
return;
}
std::vector<string> policy_names = _role->get_role_policy_names();
s->formatter->open_object_section("ListRolePoliciesResponse");
s->formatter->open_object_section("ResponseMetadata");
s->formatter->dump_string("RequestId", s->trans_id);
s->formatter->close_section();
s->formatter->open_object_section("ListRolePoliciesResult");
s->formatter->open_array_section("PolicyNames");
for (const auto& it : policy_names) {
s->formatter->dump_string("member", it);
}
s->formatter->close_section();
s->formatter->close_section();
s->formatter->close_section();
}
int RGWDeleteRolePolicy::get_params()
{
role_name = s->info.args.get("RoleName");
policy_name = s->info.args.get("PolicyName");
if (role_name.empty() || policy_name.empty()) {
ldpp_dout(this, 20) << "ERROR: One of role name or policy name is empty"<< dendl;
return -EINVAL;
}
return 0;
}
void RGWDeleteRolePolicy::execute(optional_yield y)
{
op_ret = get_params();
if (op_ret < 0) {
return;
}
if (!driver->is_meta_master()) {
RGWXMLDecoder::XMLParser parser;
if (!parser.init()) {
ldpp_dout(this, 0) << "ERROR: failed to initialize xml parser" << dendl;
op_ret = -EINVAL;
return;
}
bufferlist data;
s->info.args.remove("RoleName");
s->info.args.remove("PolicyName");
s->info.args.remove("Action");
s->info.args.remove("Version");
RGWUserInfo info = s->user->get_info();
const auto& it = info.access_keys.begin();
RGWAccessKey key;
if (it != info.access_keys.end()) {
key.id = it->first;
RGWAccessKey cred = it->second;
key.key = cred.key;
}
op_ret = driver->forward_iam_request_to_master(s, key, nullptr, bl_post_body, &parser, s->info, y);
if (op_ret < 0) {
ldpp_dout(this, 20) << "ERROR: forward_iam_request_to_master failed with error code: " << op_ret << dendl;
return;
}
}
op_ret = _role->delete_policy(this, policy_name);
if (op_ret == -ENOENT) {
op_ret = -ERR_NO_ROLE_FOUND;
return;
}
if (op_ret == 0) {
op_ret = _role->update(this, y);
}
s->formatter->open_object_section("DeleteRolePoliciesResponse");
s->formatter->open_object_section("ResponseMetadata");
s->formatter->dump_string("RequestId", s->trans_id);
s->formatter->close_section();
s->formatter->close_section();
}
int RGWTagRole::get_params()
{
role_name = s->info.args.get("RoleName");
if (role_name.empty()) {
ldout(s->cct, 0) << "ERROR: Role name is empty" << dendl;
return -EINVAL;
}
int ret = parse_tags();
if (ret < 0) {
return ret;
}
return 0;
}
void RGWTagRole::execute(optional_yield y)
{
op_ret = get_params();
if (op_ret < 0) {
return;
}
if (!driver->is_meta_master()) {
RGWXMLDecoder::XMLParser parser;
if (!parser.init()) {
ldpp_dout(this, 0) << "ERROR: failed to initialize xml parser" << dendl;
op_ret = -EINVAL;
return;
}
bufferlist data;
s->info.args.remove("RoleName");
s->info.args.remove("Action");
s->info.args.remove("Version");
auto& val_map = s->info.args.get_params();
for (auto it = val_map.begin(); it!= val_map.end(); it++) {
if (it->first.find("Tags.member.") == 0) {
val_map.erase(it);
}
}
RGWUserInfo info = s->user->get_info();
const auto& it = info.access_keys.begin();
RGWAccessKey key;
if (it != info.access_keys.end()) {
key.id = it->first;
RGWAccessKey cred = it->second;
key.key = cred.key;
}
op_ret = driver->forward_iam_request_to_master(s, key, nullptr, bl_post_body, &parser, s->info, y);
if (op_ret < 0) {
ldpp_dout(this, 20) << "ERROR: forward_iam_request_to_master failed with error code: " << op_ret << dendl;
return;
}
}
op_ret = _role->set_tags(this, tags);
if (op_ret == 0) {
op_ret = _role->update(this, y);
}
if (op_ret == 0) {
s->formatter->open_object_section("TagRoleResponse");
s->formatter->open_object_section("ResponseMetadata");
s->formatter->dump_string("RequestId", s->trans_id);
s->formatter->close_section();
s->formatter->close_section();
}
}
int RGWListRoleTags::get_params()
{
role_name = s->info.args.get("RoleName");
if (role_name.empty()) {
ldout(s->cct, 0) << "ERROR: Role name is empty" << dendl;
return -EINVAL;
}
return 0;
}
void RGWListRoleTags::execute(optional_yield y)
{
op_ret = get_params();
if (op_ret < 0) {
return;
}
boost::optional<multimap<string,string>> tag_map = _role->get_tags();
s->formatter->open_object_section("ListRoleTagsResponse");
s->formatter->open_object_section("ListRoleTagsResult");
if (tag_map) {
s->formatter->open_array_section("Tags");
for (const auto& it : tag_map.get()) {
s->formatter->open_object_section("Key");
encode_json("Key", it.first, s->formatter);
s->formatter->close_section();
s->formatter->open_object_section("Value");
encode_json("Value", it.second, s->formatter);
s->formatter->close_section();
}
s->formatter->close_section();
}
s->formatter->close_section();
s->formatter->open_object_section("ResponseMetadata");
s->formatter->dump_string("RequestId", s->trans_id);
s->formatter->close_section();
s->formatter->close_section();
}
int RGWUntagRole::get_params()
{
role_name = s->info.args.get("RoleName");
if (role_name.empty()) {
ldout(s->cct, 0) << "ERROR: Role name is empty" << dendl;
return -EINVAL;
}
auto val_map = s->info.args.get_params();
for (auto& it : val_map) {
if (it.first.find("TagKeys.member.") != string::npos) {
tagKeys.emplace_back(it.second);
}
}
return 0;
}
void RGWUntagRole::execute(optional_yield y)
{
op_ret = get_params();
if (op_ret < 0) {
return;
}
if (!driver->is_meta_master()) {
RGWXMLDecoder::XMLParser parser;
if (!parser.init()) {
ldpp_dout(this, 0) << "ERROR: failed to initialize xml parser" << dendl;
op_ret = -EINVAL;
return;
}
bufferlist data;
s->info.args.remove("RoleName");
s->info.args.remove("Action");
s->info.args.remove("Version");
auto& val_map = s->info.args.get_params();
std::vector<std::multimap<std::string, std::string>::iterator> iters;
for (auto it = val_map.begin(); it!= val_map.end(); it++) {
if (it->first.find("Tags.member.") == 0) {
iters.emplace_back(it);
}
}
for (auto& it : iters) {
val_map.erase(it);
}
RGWUserInfo info = s->user->get_info();
const auto& it = info.access_keys.begin();
RGWAccessKey key;
if (it != info.access_keys.end()) {
key.id = it->first;
RGWAccessKey cred = it->second;
key.key = cred.key;
}
op_ret = driver->forward_iam_request_to_master(s, key, nullptr, bl_post_body, &parser, s->info, y);
if (op_ret < 0) {
ldpp_dout(this, 20) << "ERROR: forward_iam_request_to_master failed with error code: " << op_ret << dendl;
return;
}
}
_role->erase_tags(tagKeys);
op_ret = _role->update(this, y);
if (op_ret == 0) {
s->formatter->open_object_section("UntagRoleResponse");
s->formatter->open_object_section("ResponseMetadata");
s->formatter->dump_string("RequestId", s->trans_id);
s->formatter->close_section();
s->formatter->close_section();
}
}
int RGWUpdateRole::get_params()
{
role_name = s->info.args.get("RoleName");
max_session_duration = s->info.args.get("MaxSessionDuration");
if (role_name.empty()) {
ldpp_dout(this, 20) << "ERROR: Role name is empty"<< dendl;
return -EINVAL;
}
return 0;
}
void RGWUpdateRole::execute(optional_yield y)
{
op_ret = get_params();
if (op_ret < 0) {
return;
}
if (!driver->is_meta_master()) {
RGWXMLDecoder::XMLParser parser;
if (!parser.init()) {
ldpp_dout(this, 0) << "ERROR: failed to initialize xml parser" << dendl;
op_ret = -EINVAL;
return;
}
bufferlist data;
s->info.args.remove("RoleName");
s->info.args.remove("MaxSessionDuration");
s->info.args.remove("Action");
s->info.args.remove("Version");
RGWUserInfo info = s->user->get_info();
const auto& it = info.access_keys.begin();
RGWAccessKey key;
if (it != info.access_keys.end()) {
key.id = it->first;
RGWAccessKey cred = it->second;
key.key = cred.key;
}
op_ret = driver->forward_iam_request_to_master(s, key, nullptr, bl_post_body, &parser, s->info, y);
if (op_ret < 0) {
ldpp_dout(this, 20) << "ERROR: forward_iam_request_to_master failed with error code: " << op_ret << dendl;
return;
}
}
if (!_role->validate_max_session_duration(this)) {
op_ret = -EINVAL;
return;
}
_role->update_max_session_duration(max_session_duration);
op_ret = _role->update(this, y);
s->formatter->open_object_section("UpdateRoleResponse");
s->formatter->open_object_section("UpdateRoleResult");
s->formatter->open_object_section("ResponseMetadata");
s->formatter->dump_string("RequestId", s->trans_id);
s->formatter->close_section();
s->formatter->close_section();
}
| 28,257 | 26.622678 | 133 |
cc
|
null |
ceph-main/src/rgw/rgw_rest_role.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#pragma once
#include "common/async/yield_context.h"
#include "rgw_role.h"
#include "rgw_rest.h"
class RGWRestRole : public RGWRESTOp {
protected:
std::string role_name;
std::string role_path;
std::string trust_policy;
std::string policy_name;
std::string perm_policy;
std::string path_prefix;
std::string max_session_duration;
std::multimap<std::string,std::string> tags;
std::vector<std::string> tagKeys;
std::unique_ptr<rgw::sal::RGWRole> _role;
int verify_permission(optional_yield y) override;
void send_response() override;
virtual uint64_t get_op() = 0;
int parse_tags();
};
class RGWRoleRead : public RGWRestRole {
public:
RGWRoleRead() = default;
int check_caps(const RGWUserCaps& caps) override;
};
class RGWRoleWrite : public RGWRestRole {
public:
RGWRoleWrite() = default;
int check_caps(const RGWUserCaps& caps) override;
};
class RGWCreateRole : public RGWRoleWrite {
bufferlist bl_post_body;
public:
RGWCreateRole(const bufferlist& bl_post_body) : bl_post_body(bl_post_body) {};
int verify_permission(optional_yield y) override;
void execute(optional_yield y) override;
int get_params();
const char* name() const override { return "create_role"; }
RGWOpType get_type() override { return RGW_OP_CREATE_ROLE; }
uint64_t get_op() override { return rgw::IAM::iamCreateRole; }
};
class RGWDeleteRole : public RGWRoleWrite {
bufferlist bl_post_body;
public:
RGWDeleteRole(const bufferlist& bl_post_body) : bl_post_body(bl_post_body) {};
void execute(optional_yield y) override;
int get_params();
const char* name() const override { return "delete_role"; }
RGWOpType get_type() override { return RGW_OP_DELETE_ROLE; }
uint64_t get_op() override { return rgw::IAM::iamDeleteRole; }
};
class RGWGetRole : public RGWRoleRead {
int _verify_permission(const rgw::sal::RGWRole* role);
public:
RGWGetRole() = default;
int verify_permission(optional_yield y) override;
void execute(optional_yield y) override;
int get_params();
const char* name() const override { return "get_role"; }
RGWOpType get_type() override { return RGW_OP_GET_ROLE; }
uint64_t get_op() override { return rgw::IAM::iamGetRole; }
};
class RGWModifyRoleTrustPolicy : public RGWRoleWrite {
bufferlist bl_post_body;
public:
RGWModifyRoleTrustPolicy(const bufferlist& bl_post_body) : bl_post_body(bl_post_body) {};
void execute(optional_yield y) override;
int get_params();
const char* name() const override { return "modify_role_trust_policy"; }
RGWOpType get_type() override { return RGW_OP_MODIFY_ROLE_TRUST_POLICY; }
uint64_t get_op() override { return rgw::IAM::iamModifyRoleTrustPolicy; }
};
class RGWListRoles : public RGWRoleRead {
public:
RGWListRoles() = default;
int verify_permission(optional_yield y) override;
void execute(optional_yield y) override;
int get_params();
const char* name() const override { return "list_roles"; }
RGWOpType get_type() override { return RGW_OP_LIST_ROLES; }
uint64_t get_op() override { return rgw::IAM::iamListRoles; }
};
class RGWPutRolePolicy : public RGWRoleWrite {
bufferlist bl_post_body;
public:
RGWPutRolePolicy(const bufferlist& bl_post_body) : bl_post_body(bl_post_body) {};
void execute(optional_yield y) override;
int get_params();
const char* name() const override { return "put_role_policy"; }
RGWOpType get_type() override { return RGW_OP_PUT_ROLE_POLICY; }
uint64_t get_op() override { return rgw::IAM::iamPutRolePolicy; }
};
class RGWGetRolePolicy : public RGWRoleRead {
public:
RGWGetRolePolicy() = default;
void execute(optional_yield y) override;
int get_params();
const char* name() const override { return "get_role_policy"; }
RGWOpType get_type() override { return RGW_OP_GET_ROLE_POLICY; }
uint64_t get_op() override { return rgw::IAM::iamGetRolePolicy; }
};
class RGWListRolePolicies : public RGWRoleRead {
public:
RGWListRolePolicies() = default;
void execute(optional_yield y) override;
int get_params();
const char* name() const override { return "list_role_policies"; }
RGWOpType get_type() override { return RGW_OP_LIST_ROLE_POLICIES; }
uint64_t get_op() override { return rgw::IAM::iamListRolePolicies; }
};
class RGWDeleteRolePolicy : public RGWRoleWrite {
bufferlist bl_post_body;
public:
RGWDeleteRolePolicy(const bufferlist& bl_post_body) : bl_post_body(bl_post_body) {};
void execute(optional_yield y) override;
int get_params();
const char* name() const override { return "delete_role_policy"; }
RGWOpType get_type() override { return RGW_OP_DELETE_ROLE_POLICY; }
uint64_t get_op() override { return rgw::IAM::iamDeleteRolePolicy; }
};
class RGWTagRole : public RGWRoleWrite {
bufferlist bl_post_body;
public:
RGWTagRole(const bufferlist& bl_post_body) : bl_post_body(bl_post_body) {};
void execute(optional_yield y) override;
int get_params();
const char* name() const override { return "tag_role"; }
RGWOpType get_type() override { return RGW_OP_TAG_ROLE; }
uint64_t get_op() override { return rgw::IAM::iamTagRole; }
};
class RGWListRoleTags : public RGWRoleRead {
public:
RGWListRoleTags() = default;
void execute(optional_yield y) override;
int get_params();
const char* name() const override { return "list_role_tags"; }
RGWOpType get_type() override { return RGW_OP_LIST_ROLE_TAGS; }
uint64_t get_op() override { return rgw::IAM::iamListRoleTags; }
};
class RGWUntagRole : public RGWRoleWrite {
bufferlist bl_post_body;
public:
RGWUntagRole(const bufferlist& bl_post_body) : bl_post_body(bl_post_body) {};
void execute(optional_yield y) override;
int get_params();
const char* name() const override { return "untag_role"; }
RGWOpType get_type() override { return RGW_OP_UNTAG_ROLE; }
uint64_t get_op() override { return rgw::IAM::iamUntagRole; }
};
class RGWUpdateRole : public RGWRoleWrite {
bufferlist bl_post_body;
public:
RGWUpdateRole(const bufferlist& bl_post_body) : bl_post_body(bl_post_body) {};
void execute(optional_yield y) override;
int get_params();
const char* name() const override { return "update_role"; }
RGWOpType get_type() override { return RGW_OP_UPDATE_ROLE; }
uint64_t get_op() override { return rgw::IAM::iamUpdateRole; }
};
| 6,347 | 34.071823 | 91 |
h
|
null |
ceph-main/src/rgw/rgw_rest_s3.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#include <errno.h>
#include <array>
#include <string.h>
#include <string_view>
#include "common/ceph_crypto.h"
#include "common/split.h"
#include "common/Formatter.h"
#include "common/utf8.h"
#include "common/ceph_json.h"
#include "common/safe_io.h"
#include "common/errno.h"
#include "auth/Crypto.h"
#include <boost/algorithm/string.hpp>
#include <boost/algorithm/string/replace.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/tokenizer.hpp>
#define BOOST_BIND_GLOBAL_PLACEHOLDERS
#ifdef HAVE_WARN_IMPLICIT_CONST_INT_FLOAT_CONVERSION
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wimplicit-const-int-float-conversion"
#endif
#ifdef HAVE_WARN_IMPLICIT_CONST_INT_FLOAT_CONVERSION
#pragma clang diagnostic pop
#endif
#undef BOOST_BIND_GLOBAL_PLACEHOLDERS
#include <liboath/oath.h>
#include "rgw_rest.h"
#include "rgw_rest_s3.h"
#include "rgw_rest_s3website.h"
#include "rgw_rest_pubsub.h"
#include "rgw_auth_s3.h"
#include "rgw_acl.h"
#include "rgw_policy_s3.h"
#include "rgw_user.h"
#include "rgw_cors.h"
#include "rgw_cors_s3.h"
#include "rgw_tag_s3.h"
#include "rgw_client_io.h"
#include "rgw_keystone.h"
#include "rgw_auth_keystone.h"
#include "rgw_auth_registry.h"
#include "rgw_es_query.h"
#include <typeinfo> // for 'typeid'
#include "rgw_ldap.h"
#include "rgw_token.h"
#include "rgw_rest_role.h"
#include "rgw_crypt.h"
#include "rgw_crypt_sanitize.h"
#include "rgw_rest_user_policy.h"
#include "rgw_zone.h"
#include "rgw_bucket_sync.h"
#include "include/ceph_assert.h"
#include "rgw_role.h"
#include "rgw_rest_sts.h"
#include "rgw_rest_iam.h"
#include "rgw_sts.h"
#include "rgw_sal_rados.h"
#include "rgw_s3select.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rgw
using namespace std;
using namespace rgw;
using namespace ceph::crypto;
void list_all_buckets_start(req_state *s)
{
s->formatter->open_array_section_in_ns("ListAllMyBucketsResult", XMLNS_AWS_S3);
}
void list_all_buckets_end(req_state *s)
{
s->formatter->close_section();
}
void dump_bucket(req_state *s, rgw::sal::Bucket& obj)
{
s->formatter->open_object_section("Bucket");
s->formatter->dump_string("Name", obj.get_name());
dump_time(s, "CreationDate", obj.get_creation_time());
s->formatter->close_section();
}
void rgw_get_errno_s3(rgw_http_error *e , int err_no)
{
rgw_http_errors::const_iterator r = rgw_http_s3_errors.find(err_no);
if (r != rgw_http_s3_errors.end()) {
e->http_ret = r->second.first;
e->s3_code = r->second.second;
} else {
e->http_ret = 500;
e->s3_code = "UnknownError";
}
}
static inline std::string get_s3_expiration_header(
req_state* s,
const ceph::real_time& mtime)
{
return rgw::lc::s3_expiration_header(
s, s->object->get_key(), s->tagset, mtime, s->bucket_attrs);
}
static inline bool get_s3_multipart_abort_header(
req_state* s, const ceph::real_time& mtime,
ceph::real_time& date, std::string& rule_id)
{
return rgw::lc::s3_multipart_abort_header(
s, s->object->get_key(), mtime, s->bucket_attrs, date, rule_id);
}
struct response_attr_param {
const char *param;
const char *http_attr;
};
static struct response_attr_param resp_attr_params[] = {
{"response-content-type", "Content-Type"},
{"response-content-language", "Content-Language"},
{"response-expires", "Expires"},
{"response-cache-control", "Cache-Control"},
{"response-content-disposition", "Content-Disposition"},
{"response-content-encoding", "Content-Encoding"},
{NULL, NULL},
};
#define SSE_C_GROUP 1
#define KMS_GROUP 2
int get_encryption_defaults(req_state *s)
{
int meta_sse_group = 0;
constexpr auto sse_c_prefix = "x-amz-server-side-encryption-customer-";
constexpr auto encrypt_attr = "x-amz-server-side-encryption";
constexpr auto context_attr = "x-amz-server-side-encryption-context";
constexpr auto kms_attr = "x-amz-server-side-encryption-aws-kms-key-id";
constexpr auto bucket_key_attr = "x-amz-server-side-encryption-bucket-key-enabled";
bool bucket_configuration_found { false };
bool rest_only { false };
for (auto& kv : s->info.crypt_attribute_map) {
if (kv.first.find(sse_c_prefix) == 0)
meta_sse_group |= SSE_C_GROUP;
else if (kv.first.find(encrypt_attr) == 0)
meta_sse_group |= KMS_GROUP;
}
if (meta_sse_group == (SSE_C_GROUP|KMS_GROUP)) {
s->err.message = "Server side error - can't do sse-c & sse-kms|sse-s3";
return -EINVAL;
}
const auto& buck_attrs = s->bucket_attrs;
auto aiter = buck_attrs.find(RGW_ATTR_BUCKET_ENCRYPTION_POLICY);
RGWBucketEncryptionConfig bucket_encryption_conf;
if (aiter != buck_attrs.end()) {
ldpp_dout(s, 5) << "Found RGW_ATTR_BUCKET_ENCRYPTION_POLICY on "
<< s->bucket_name << dendl;
bufferlist::const_iterator iter{&aiter->second};
try {
bucket_encryption_conf.decode(iter);
bucket_configuration_found = true;
} catch (const buffer::error& e) {
s->err.message = "Server side error - can't decode bucket_encryption_conf";
ldpp_dout(s, 5) << __func__ << "decode bucket_encryption_conf failed" << dendl;
return -EINVAL;
}
}
if (meta_sse_group & SSE_C_GROUP) {
ldpp_dout(s, 20) << "get_encryption_defaults: no defaults cause sse-c forced"
<< dendl;
return 0; // sse-c: no defaults here
}
std::string sse_algorithm { bucket_encryption_conf.sse_algorithm() };
auto kms_master_key_id { bucket_encryption_conf.kms_master_key_id() };
bool bucket_key_enabled { bucket_encryption_conf.bucket_key_enabled() };
bool kms_attr_seen = false;
if (bucket_configuration_found) {
ldpp_dout(s, 5) << "RGW_ATTR_BUCKET_ENCRYPTION ALGO: "
<< sse_algorithm << dendl;
}
auto iter = s->info.crypt_attribute_map.find(encrypt_attr);
if (iter != s->info.crypt_attribute_map.end()) {
ldpp_dout(s, 20) << "get_encryption_defaults: found encrypt_attr " << encrypt_attr << " = " << iter->second << ", setting sse_algorithm to that" << dendl;
rest_only = true;
sse_algorithm = iter->second;
} else if (sse_algorithm != "") {
rgw_set_amz_meta_header(s->info.crypt_attribute_map, encrypt_attr, sse_algorithm, OVERWRITE);
}
iter = s->info.crypt_attribute_map.find(kms_attr);
if (iter != s->info.crypt_attribute_map.end()) {
ldpp_dout(s, 20) << "get_encryption_defaults: found kms_attr " << kms_attr << " = " << iter->second << ", setting kms_attr_seen" << dendl;
if (!rest_only) {
s->err.message = std::string("incomplete rest sse parms: ") + kms_attr + " not valid without kms";
ldpp_dout(s, 5) << __func__ << "argument problem: " << s->err.message << dendl;
return -EINVAL;
}
kms_attr_seen = true;
} else if (!rest_only && kms_master_key_id != "") {
ldpp_dout(s, 20) << "get_encryption_defaults: no kms_attr, but kms_master_key_id = " << kms_master_key_id << ", settig kms_attr_seen" << dendl;
kms_attr_seen = true;
rgw_set_amz_meta_header(s->info.crypt_attribute_map, kms_attr, kms_master_key_id, OVERWRITE);
}
iter = s->info.crypt_attribute_map.find(bucket_key_attr);
if (iter != s->info.crypt_attribute_map.end()) {
ldpp_dout(s, 20) << "get_encryption_defaults: found bucket_key_attr " << bucket_key_attr << " = " << iter->second << ", setting kms_attr_seen" << dendl;
if (!rest_only) {
s->err.message = std::string("incomplete rest sse parms: ") + bucket_key_attr + " not valid without kms";
ldpp_dout(s, 5) << __func__ << "argument problem: " << s->err.message << dendl;
return -EINVAL;
}
kms_attr_seen = true;
} else if (!rest_only && bucket_key_enabled) {
ldpp_dout(s, 20) << "get_encryption_defaults: no bucket_key_attr, but bucket_key_enabled, setting kms_attr_seen" << dendl;
kms_attr_seen = true;
rgw_set_amz_meta_header(s->info.crypt_attribute_map, bucket_key_attr, "true", OVERWRITE);
}
iter = s->info.crypt_attribute_map.find(context_attr);
if (iter != s->info.crypt_attribute_map.end()) {
ldpp_dout(s, 20) << "get_encryption_defaults: found context_attr " << context_attr << " = " << iter->second << ", setting kms_attr_seen" << dendl;
if (!rest_only) {
s->err.message = std::string("incomplete rest sse parms: ") + context_attr + " not valid without kms";
ldpp_dout(s, 5) << __func__ << "argument problem: " << s->err.message << dendl;
return -EINVAL;
}
kms_attr_seen = true;
}
if (kms_attr_seen && sse_algorithm == "") {
ldpp_dout(s, 20) << "get_encryption_defaults: kms_attr but no algorithm, defaulting to aws_kms" << dendl;
sse_algorithm = "aws:kms";
}
for (const auto& kv: s->info.crypt_attribute_map) {
ldpp_dout(s, 20) << "get_encryption_defaults: final map: " << kv.first << " = " << kv.second << dendl;
}
ldpp_dout(s, 20) << "get_encryption_defaults: kms_attr_seen is " << kms_attr_seen << " and sse_algorithm is " << sse_algorithm << dendl;
if (kms_attr_seen && sse_algorithm != "aws:kms") {
s->err.message = "algorithm <" + sse_algorithm + "> but got sse-kms attributes";
return -EINVAL;
}
return 0;
}
int RGWGetObj_ObjStore_S3Website::send_response_data(bufferlist& bl, off_t bl_ofs, off_t bl_len) {
map<string, bufferlist>::iterator iter;
iter = attrs.find(RGW_ATTR_AMZ_WEBSITE_REDIRECT_LOCATION);
if (iter != attrs.end()) {
bufferlist &bl = iter->second;
s->redirect = bl.c_str();
s->err.http_ret = 301;
ldpp_dout(this, 20) << __CEPH_ASSERT_FUNCTION << " redirecting per x-amz-website-redirect-location=" << s->redirect << dendl;
op_ret = -ERR_WEBSITE_REDIRECT;
set_req_state_err(s, op_ret);
dump_errno(s);
dump_content_length(s, 0);
dump_redirect(s, s->redirect);
end_header(s, this);
return op_ret;
} else {
return RGWGetObj_ObjStore_S3::send_response_data(bl, bl_ofs, bl_len);
}
}
int RGWGetObj_ObjStore_S3Website::send_response_data_error(optional_yield y)
{
return RGWGetObj_ObjStore_S3::send_response_data_error(y);
}
int RGWGetObj_ObjStore_S3::get_params(optional_yield y)
{
// for multisite sync requests, only read the slo manifest itself, rather than
// all of the data from its parts. the parts will sync as separate objects
skip_manifest = s->info.args.exists(RGW_SYS_PARAM_PREFIX "sync-manifest");
// multisite sync requests should fetch encrypted data, along with the
// attributes needed to support decryption on the other zone
if (s->system_request) {
skip_decrypt = s->info.args.exists(RGW_SYS_PARAM_PREFIX "skip-decrypt");
}
// multisite sync requests should fetch cloudtiered objects
sync_cloudtiered = s->info.args.exists(RGW_SYS_PARAM_PREFIX "sync-cloudtiered");
dst_zone_trace = s->info.args.get(RGW_SYS_PARAM_PREFIX "if-not-replicated-to");
get_torrent = s->info.args.exists("torrent");
return RGWGetObj_ObjStore::get_params(y);
}
int RGWGetObj_ObjStore_S3::send_response_data_error(optional_yield y)
{
bufferlist bl;
return send_response_data(bl, 0 , 0);
}
template <class T>
int decode_attr_bl_single_value(map<string, bufferlist>& attrs, const char *attr_name, T *result, T def_val)
{
map<string, bufferlist>::iterator iter = attrs.find(attr_name);
if (iter == attrs.end()) {
*result = def_val;
return 0;
}
bufferlist& bl = iter->second;
if (bl.length() == 0) {
*result = def_val;
return 0;
}
auto bliter = bl.cbegin();
try {
decode(*result, bliter);
} catch (buffer::error& err) {
return -EIO;
}
return 0;
}
inline bool str_has_cntrl(const std::string s) {
return std::any_of(s.begin(), s.end(), ::iscntrl);
}
inline bool str_has_cntrl(const char* s) {
std::string _s(s);
return str_has_cntrl(_s);
}
int RGWGetObj_ObjStore_S3::send_response_data(bufferlist& bl, off_t bl_ofs,
off_t bl_len)
{
const char *content_type = NULL;
string content_type_str;
map<string, string> response_attrs;
map<string, string>::iterator riter;
bufferlist metadata_bl;
string expires = get_s3_expiration_header(s, lastmod);
if (sent_header)
goto send_data;
if (custom_http_ret) {
set_req_state_err(s, 0);
dump_errno(s, custom_http_ret);
} else {
set_req_state_err(s, (partial_content && !op_ret) ? STATUS_PARTIAL_CONTENT
: op_ret);
dump_errno(s);
}
if (op_ret)
goto done;
if (range_str)
dump_range(s, start, end, s->obj_size);
if (s->system_request &&
s->info.args.exists(RGW_SYS_PARAM_PREFIX "prepend-metadata")) {
dump_header(s, "Rgwx-Object-Size", (long long)total_len);
if (rgwx_stat) {
/*
* in this case, we're not returning the object's content, only the prepended
* extra metadata
*/
total_len = 0;
}
/* JSON encode object metadata */
JSONFormatter jf;
jf.open_object_section("obj_metadata");
encode_json("attrs", attrs, &jf);
utime_t ut(lastmod);
encode_json("mtime", ut, &jf);
jf.close_section();
stringstream ss;
jf.flush(ss);
metadata_bl.append(ss.str());
dump_header(s, "Rgwx-Embedded-Metadata-Len", metadata_bl.length());
total_len += metadata_bl.length();
}
if (s->system_request && !real_clock::is_zero(lastmod)) {
/* we end up dumping mtime in two different methods, a bit redundant */
dump_epoch_header(s, "Rgwx-Mtime", lastmod);
uint64_t pg_ver = 0;
int r = decode_attr_bl_single_value(attrs, RGW_ATTR_PG_VER, &pg_ver, (uint64_t)0);
if (r < 0) {
ldpp_dout(this, 0) << "ERROR: failed to decode pg ver attr, ignoring" << dendl;
}
dump_header(s, "Rgwx-Obj-PG-Ver", pg_ver);
uint32_t source_zone_short_id = 0;
r = decode_attr_bl_single_value(attrs, RGW_ATTR_SOURCE_ZONE, &source_zone_short_id, (uint32_t)0);
if (r < 0) {
ldpp_dout(this, 0) << "ERROR: failed to decode pg ver attr, ignoring" << dendl;
}
if (source_zone_short_id != 0) {
dump_header(s, "Rgwx-Source-Zone-Short-Id", source_zone_short_id);
}
}
for (auto &it : crypt_http_responses)
dump_header(s, it.first, it.second);
dump_content_length(s, total_len);
dump_last_modified(s, lastmod);
dump_header_if_nonempty(s, "x-amz-version-id", version_id);
dump_header_if_nonempty(s, "x-amz-expiration", expires);
if (attrs.find(RGW_ATTR_APPEND_PART_NUM) != attrs.end()) {
dump_header(s, "x-rgw-object-type", "Appendable");
dump_header(s, "x-rgw-next-append-position", s->obj_size);
} else {
dump_header(s, "x-rgw-object-type", "Normal");
}
// replication status
if (auto i = attrs.find(RGW_ATTR_OBJ_REPLICATION_STATUS);
i != attrs.end()) {
dump_header(s, "x-amz-replication-status", i->second);
}
if (auto i = attrs.find(RGW_ATTR_OBJ_REPLICATION_TRACE);
i != attrs.end()) {
try {
std::vector<rgw_zone_set_entry> zones;
auto p = i->second.cbegin();
decode(zones, p);
for (const auto& zone : zones) {
dump_header(s, "x-rgw-replicated-from", zone.to_str());
}
} catch (const buffer::error&) {} // omit x-rgw-replicated-from headers
}
if (! op_ret) {
if (! lo_etag.empty()) {
/* Handle etag of Swift API's large objects (DLO/SLO). It's entirerly
* legit to perform GET on them through S3 API. In such situation,
* a client should receive the composited content with corresponding
* etag value. */
dump_etag(s, lo_etag);
} else {
auto iter = attrs.find(RGW_ATTR_ETAG);
if (iter != attrs.end()) {
dump_etag(s, iter->second.to_str());
}
}
for (struct response_attr_param *p = resp_attr_params; p->param; p++) {
bool exists;
string val = s->info.args.get(p->param, &exists);
if (exists) {
/* reject unauthenticated response header manipulation, see
* https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html */
if (s->auth.identity->is_anonymous()) {
return -ERR_INVALID_REQUEST;
}
/* HTTP specification says no control characters should be present in
* header values: https://tools.ietf.org/html/rfc7230#section-3.2
* field-vchar = VCHAR / obs-text
*
* Failure to validate this permits a CRLF injection in HTTP headers,
* whereas S3 GetObject only permits specific headers.
*/
if(str_has_cntrl(val)) {
/* TODO: return a more distinct error in future;
* stating what the problem is */
return -ERR_INVALID_REQUEST;
}
if (strcmp(p->param, "response-content-type") != 0) {
response_attrs[p->http_attr] = val;
} else {
content_type_str = val;
content_type = content_type_str.c_str();
}
}
}
for (auto iter = attrs.begin(); iter != attrs.end(); ++iter) {
const char *name = iter->first.c_str();
map<string, string>::iterator aiter = rgw_to_http_attrs.find(name);
if (aiter != rgw_to_http_attrs.end()) {
if (response_attrs.count(aiter->second) == 0) {
/* Was not already overridden by a response param. */
size_t len = iter->second.length();
string s(iter->second.c_str(), len);
while (len && !s[len - 1]) {
--len;
s.resize(len);
}
response_attrs[aiter->second] = s;
}
} else if (iter->first.compare(RGW_ATTR_CONTENT_TYPE) == 0) {
/* Special handling for content_type. */
if (!content_type) {
content_type_str = rgw_bl_str(iter->second);
content_type = content_type_str.c_str();
}
} else if (strcmp(name, RGW_ATTR_SLO_UINDICATOR) == 0) {
// this attr has an extra length prefix from encode() in prior versions
dump_header(s, "X-Object-Meta-Static-Large-Object", "True");
} else if (strncmp(name, RGW_ATTR_META_PREFIX,
sizeof(RGW_ATTR_META_PREFIX)-1) == 0) {
/* User custom metadata. */
name += sizeof(RGW_ATTR_PREFIX) - 1;
dump_header(s, name, iter->second);
} else if (iter->first.compare(RGW_ATTR_TAGS) == 0) {
RGWObjTags obj_tags;
try{
auto it = iter->second.cbegin();
obj_tags.decode(it);
} catch (buffer::error &err) {
ldpp_dout(this,0) << "Error caught buffer::error couldn't decode TagSet " << dendl;
}
dump_header(s, RGW_AMZ_TAG_COUNT, obj_tags.count());
} else if (iter->first.compare(RGW_ATTR_OBJECT_RETENTION) == 0 && get_retention){
RGWObjectRetention retention;
try {
decode(retention, iter->second);
dump_header(s, "x-amz-object-lock-mode", retention.get_mode());
string date = ceph::to_iso_8601(retention.get_retain_until_date());
dump_header(s, "x-amz-object-lock-retain-until-date", date.c_str());
} catch (buffer::error& err) {
ldpp_dout(this, 0) << "ERROR: failed to decode RGWObjectRetention" << dendl;
}
} else if (iter->first.compare(RGW_ATTR_OBJECT_LEGAL_HOLD) == 0 && get_legal_hold) {
RGWObjectLegalHold legal_hold;
try {
decode(legal_hold, iter->second);
dump_header(s, "x-amz-object-lock-legal-hold",legal_hold.get_status());
} catch (buffer::error& err) {
ldpp_dout(this, 0) << "ERROR: failed to decode RGWObjectLegalHold" << dendl;
}
}
}
}
done:
for (riter = response_attrs.begin(); riter != response_attrs.end();
++riter) {
dump_header(s, riter->first, riter->second);
}
if (op_ret == -ERR_NOT_MODIFIED) {
end_header(s, this);
} else {
if (!content_type)
content_type = "binary/octet-stream";
end_header(s, this, content_type);
}
if (metadata_bl.length()) {
dump_body(s, metadata_bl);
}
sent_header = true;
send_data:
if (get_data && !op_ret) {
int r = dump_body(s, bl.c_str() + bl_ofs, bl_len);
if (r < 0)
return r;
}
return 0;
}
int RGWGetObj_ObjStore_S3::get_decrypt_filter(std::unique_ptr<RGWGetObj_Filter> *filter, RGWGetObj_Filter* cb, bufferlist* manifest_bl)
{
if (skip_decrypt) { // bypass decryption for multisite sync requests
return 0;
}
int res = 0;
std::unique_ptr<BlockCrypt> block_crypt;
res = rgw_s3_prepare_decrypt(s, attrs, &block_crypt, crypt_http_responses);
if (res == 0) {
if (block_crypt != nullptr) {
auto f = std::make_unique<RGWGetObj_BlockDecrypt>(s, s->cct, cb, std::move(block_crypt), s->yield);
if (manifest_bl != nullptr) {
res = f->read_manifest(this, *manifest_bl);
if (res == 0) {
*filter = std::move(f);
}
}
}
}
return res;
}
int RGWGetObj_ObjStore_S3::verify_requester(const rgw::auth::StrategyRegistry& auth_registry, optional_yield y)
{
int ret = -EINVAL;
ret = RGWOp::verify_requester(auth_registry, y);
if(!s->user->get_caps().check_cap("amz-cache", RGW_CAP_READ) && !ret && s->info.env->exists("HTTP_X_AMZ_CACHE"))
ret = override_range_hdr(auth_registry, y);
return ret;
}
int RGWGetObj_ObjStore_S3::override_range_hdr(const rgw::auth::StrategyRegistry& auth_registry, optional_yield y)
{
int ret = -EINVAL;
ldpp_dout(this, 10) << "cache override headers" << dendl;
RGWEnv* rgw_env = const_cast<RGWEnv *>(s->info.env);
const char* backup_range = rgw_env->get("HTTP_RANGE");
const char hdrs_split[2] = {(char)178,'\0'};
const char kv_split[2] = {(char)177,'\0'};
const char* cache_hdr = rgw_env->get("HTTP_X_AMZ_CACHE");
for (std::string_view hdr : ceph::split(cache_hdr, hdrs_split)) {
auto kv = ceph::split(hdr, kv_split);
auto k = kv.begin();
if (std::distance(k, kv.end()) != 2) {
return -EINVAL;
}
auto v = std::next(k);
std::string key = "HTTP_";
key.append(*k);
boost::replace_all(key, "-", "_");
ldpp_dout(this, 10) << "after splitting cache kv key: " << key << " " << *v << dendl;
rgw_env->set(std::move(key), std::string(*v));
}
ret = RGWOp::verify_requester(auth_registry, y);
if(!ret && backup_range) {
rgw_env->set("HTTP_RANGE",backup_range);
} else {
rgw_env->remove("HTTP_RANGE");
}
return ret;
}
void RGWGetObjTags_ObjStore_S3::send_response_data(bufferlist& bl)
{
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
dump_start(s);
if (!op_ret){
s->formatter->open_object_section_in_ns("Tagging", XMLNS_AWS_S3);
s->formatter->open_object_section("TagSet");
if (has_tags){
RGWObjTagSet_S3 tagset;
auto iter = bl.cbegin();
try {
tagset.decode(iter);
} catch (buffer::error& err) {
ldpp_dout(this,0) << "ERROR: caught buffer::error, couldn't decode TagSet" << dendl;
op_ret= -EIO;
return;
}
tagset.dump_xml(s->formatter);
}
s->formatter->close_section();
s->formatter->close_section();
rgw_flush_formatter_and_reset(s, s->formatter);
}
}
int RGWPutObjTags_ObjStore_S3::get_params(optional_yield y)
{
RGWXMLParser parser;
if (!parser.init()){
return -EINVAL;
}
const auto max_size = s->cct->_conf->rgw_max_put_param_size;
int r = 0;
bufferlist data;
std::tie(r, data) = read_all_input(s, max_size, false);
if (r < 0)
return r;
if (!parser.parse(data.c_str(), data.length(), 1)) {
return -ERR_MALFORMED_XML;
}
RGWObjTagging_S3 tagging;
try {
RGWXMLDecoder::decode_xml("Tagging", tagging, &parser);
} catch (RGWXMLDecoder::err& err) {
ldpp_dout(this, 5) << "Malformed tagging request: " << err << dendl;
return -ERR_MALFORMED_XML;
}
RGWObjTags obj_tags;
r = tagging.rebuild(obj_tags);
if (r < 0)
return r;
obj_tags.encode(tags_bl);
ldpp_dout(this, 20) << "Read " << obj_tags.count() << "tags" << dendl;
return 0;
}
void RGWPutObjTags_ObjStore_S3::send_response()
{
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
dump_start(s);
}
void RGWDeleteObjTags_ObjStore_S3::send_response()
{
if (op_ret == 0){
op_ret = STATUS_NO_CONTENT;
}
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
dump_start(s);
}
void RGWGetBucketTags_ObjStore_S3::send_response_data(bufferlist& bl)
{
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
dump_start(s);
if (!op_ret) {
s->formatter->open_object_section_in_ns("Tagging", XMLNS_AWS_S3);
s->formatter->open_object_section("TagSet");
if (has_tags){
RGWObjTagSet_S3 tagset;
auto iter = bl.cbegin();
try {
tagset.decode(iter);
} catch (buffer::error& err) {
ldpp_dout(this,0) << "ERROR: caught buffer::error, couldn't decode TagSet" << dendl;
op_ret= -EIO;
return;
}
tagset.dump_xml(s->formatter);
}
s->formatter->close_section();
s->formatter->close_section();
rgw_flush_formatter_and_reset(s, s->formatter);
}
}
int RGWPutBucketTags_ObjStore_S3::get_params(const DoutPrefixProvider *dpp, optional_yield y)
{
RGWXMLParser parser;
if (!parser.init()){
return -EINVAL;
}
const auto max_size = s->cct->_conf->rgw_max_put_param_size;
int r = 0;
bufferlist data;
std::tie(r, data) = read_all_input(s, max_size, false);
if (r < 0)
return r;
if (!parser.parse(data.c_str(), data.length(), 1)) {
return -ERR_MALFORMED_XML;
}
RGWObjTagging_S3 tagging;
try {
RGWXMLDecoder::decode_xml("Tagging", tagging, &parser);
} catch (RGWXMLDecoder::err& err) {
ldpp_dout(dpp, 5) << "Malformed tagging request: " << err << dendl;
return -ERR_MALFORMED_XML;
}
RGWObjTags obj_tags(50); // A tag set can contain as many as 50 tags, or it can be empty.
r = tagging.rebuild(obj_tags);
if (r < 0)
return r;
obj_tags.encode(tags_bl);
ldpp_dout(dpp, 20) << "Read " << obj_tags.count() << "tags" << dendl;
// forward bucket tags requests to meta master zone
if (!driver->is_meta_master()) {
/* only need to keep this data around if we're not meta master */
in_data = std::move(data);
}
return 0;
}
void RGWPutBucketTags_ObjStore_S3::send_response()
{
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
dump_start(s);
}
void RGWDeleteBucketTags_ObjStore_S3::send_response()
{
// A successful DeleteBucketTagging should
// return a 204 status code.
if (op_ret == 0)
op_ret = STATUS_NO_CONTENT;
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
dump_start(s);
}
namespace {
bool is_valid_status(const string& s) {
return (s == "Enabled" ||
s == "Disabled");
}
static string enabled_group_id = "s3-bucket-replication:enabled";
static string disabled_group_id = "s3-bucket-replication:disabled";
struct ReplicationConfiguration {
string role;
struct Rule {
struct DeleteMarkerReplication {
string status;
void decode_xml(XMLObj *obj) {
RGWXMLDecoder::decode_xml("Status", status, obj);
}
void dump_xml(Formatter *f) const {
encode_xml("Status", status, f);
}
bool is_valid(CephContext *cct) const {
bool result = is_valid_status(status);
if (!result) {
ldout(cct, 5) << "NOTICE: bad status provided in DeleteMarkerReplication element (status=" << status << ")" << dendl;
}
return result;
}
};
struct Source { /* rgw extension */
std::vector<string> zone_names;
void decode_xml(XMLObj *obj) {
RGWXMLDecoder::decode_xml("Zone", zone_names, obj);
}
void dump_xml(Formatter *f) const {
encode_xml("Zone", zone_names, f);
}
};
struct Destination {
struct AccessControlTranslation {
string owner;
void decode_xml(XMLObj *obj) {
RGWXMLDecoder::decode_xml("Owner", owner, obj);
}
void dump_xml(Formatter *f) const {
encode_xml("Owner", owner, f);
}
};
std::optional<AccessControlTranslation> acl_translation;
std::optional<string> account;
string bucket;
std::optional<string> storage_class;
std::vector<string> zone_names;
void decode_xml(XMLObj *obj) {
RGWXMLDecoder::decode_xml("AccessControlTranslation", acl_translation, obj);
RGWXMLDecoder::decode_xml("Account", account, obj);
if (account && account->empty()) {
account.reset();
}
RGWXMLDecoder::decode_xml("Bucket", bucket, obj);
RGWXMLDecoder::decode_xml("StorageClass", storage_class, obj);
if (storage_class && storage_class->empty()) {
storage_class.reset();
}
RGWXMLDecoder::decode_xml("Zone", zone_names, obj); /* rgw extension */
}
void dump_xml(Formatter *f) const {
encode_xml("AccessControlTranslation", acl_translation, f);
encode_xml("Account", account, f);
encode_xml("Bucket", bucket, f);
encode_xml("StorageClass", storage_class, f);
encode_xml("Zone", zone_names, f);
}
};
struct Filter {
struct Tag {
string key;
string value;
bool empty() const {
return key.empty() && value.empty();
}
void decode_xml(XMLObj *obj) {
RGWXMLDecoder::decode_xml("Key", key, obj);
RGWXMLDecoder::decode_xml("Value", value, obj);
};
void dump_xml(Formatter *f) const {
encode_xml("Key", key, f);
encode_xml("Value", value, f);
}
};
struct AndElements {
std::optional<string> prefix;
std::vector<Tag> tags;
bool empty() const {
return !prefix &&
(tags.size() == 0);
}
void decode_xml(XMLObj *obj) {
std::vector<Tag> _tags;
RGWXMLDecoder::decode_xml("Prefix", prefix, obj);
if (prefix && prefix->empty()) {
prefix.reset();
}
RGWXMLDecoder::decode_xml("Tag", _tags, obj);
for (auto& t : _tags) {
if (!t.empty()) {
tags.push_back(std::move(t));
}
}
};
void dump_xml(Formatter *f) const {
encode_xml("Prefix", prefix, f);
encode_xml("Tag", tags, f);
}
};
std::optional<string> prefix;
std::optional<Tag> tag;
std::optional<AndElements> and_elements;
bool empty() const {
return (!prefix && !tag && !and_elements);
}
void decode_xml(XMLObj *obj) {
RGWXMLDecoder::decode_xml("Prefix", prefix, obj);
if (prefix && prefix->empty()) {
prefix.reset();
}
RGWXMLDecoder::decode_xml("Tag", tag, obj);
if (tag && tag->empty()) {
tag.reset();
}
RGWXMLDecoder::decode_xml("And", and_elements, obj);
if (and_elements && and_elements->empty()) {
and_elements.reset();
}
};
void dump_xml(Formatter *f) const {
encode_xml("Prefix", prefix, f);
encode_xml("Tag", tag, f);
encode_xml("And", and_elements, f);
}
bool is_valid(CephContext *cct) const {
if (tag && prefix) {
ldout(cct, 5) << "NOTICE: both tag and prefix were provided in replication filter rule" << dendl;
return false;
}
if (and_elements) {
if (prefix && and_elements->prefix) {
ldout(cct, 5) << "NOTICE: too many prefixes were provided in re" << dendl;
return false;
}
}
return true;
};
int to_sync_pipe_filter(CephContext *cct,
rgw_sync_pipe_filter *f) const {
if (!is_valid(cct)) {
return -EINVAL;
}
if (prefix) {
f->prefix = *prefix;
}
if (tag) {
f->tags.insert(rgw_sync_pipe_filter_tag(tag->key, tag->value));
}
if (and_elements) {
if (and_elements->prefix) {
f->prefix = *and_elements->prefix;
}
for (auto& t : and_elements->tags) {
f->tags.insert(rgw_sync_pipe_filter_tag(t.key, t.value));
}
}
return 0;
}
void from_sync_pipe_filter(const rgw_sync_pipe_filter& f) {
if (f.prefix && f.tags.empty()) {
prefix = f.prefix;
return;
}
if (f.prefix) {
and_elements.emplace();
and_elements->prefix = f.prefix;
} else if (f.tags.size() == 1) {
auto iter = f.tags.begin();
if (iter == f.tags.end()) {
/* should never happen */
return;
}
auto& t = *iter;
tag.emplace();
tag->key = t.key;
tag->value = t.value;
return;
}
if (f.tags.empty()) {
return;
}
if (!and_elements) {
and_elements.emplace();
}
for (auto& t : f.tags) {
auto& tag = and_elements->tags.emplace_back();
tag.key = t.key;
tag.value = t.value;
}
}
};
set<rgw_zone_id> get_zone_ids_from_names(rgw::sal::Driver* driver,
const vector<string>& zone_names) const {
set<rgw_zone_id> ids;
for (auto& name : zone_names) {
std::unique_ptr<rgw::sal::Zone> zone;
int ret = driver->get_zone()->get_zonegroup().get_zone_by_name(name, &zone);
if (ret >= 0) {
rgw_zone_id id = zone->get_id();
ids.insert(std::move(id));
}
}
return ids;
}
vector<string> get_zone_names_from_ids(rgw::sal::Driver* driver,
const set<rgw_zone_id>& zone_ids) const {
vector<string> names;
for (auto& id : zone_ids) {
std::unique_ptr<rgw::sal::Zone> zone;
int ret = driver->get_zone()->get_zonegroup().get_zone_by_id(id.id, &zone);
if (ret >= 0) {
names.emplace_back(zone->get_name());
}
}
return names;
}
std::optional<DeleteMarkerReplication> delete_marker_replication;
std::optional<Source> source;
Destination destination;
std::optional<Filter> filter;
string id;
int32_t priority;
string status;
void decode_xml(XMLObj *obj) {
RGWXMLDecoder::decode_xml("DeleteMarkerReplication", delete_marker_replication, obj);
RGWXMLDecoder::decode_xml("Source", source, obj);
RGWXMLDecoder::decode_xml("Destination", destination, obj);
RGWXMLDecoder::decode_xml("ID", id, obj);
std::optional<string> prefix;
RGWXMLDecoder::decode_xml("Prefix", prefix, obj);
if (prefix) {
filter.emplace();
filter->prefix = prefix;
}
if (!filter) {
RGWXMLDecoder::decode_xml("Filter", filter, obj);
} else {
/* don't want to have filter reset because it might have been initialized
* when decoding prefix
*/
RGWXMLDecoder::decode_xml("Filter", *filter, obj);
}
RGWXMLDecoder::decode_xml("Priority", priority, obj);
RGWXMLDecoder::decode_xml("Status", status, obj);
}
void dump_xml(Formatter *f) const {
encode_xml("DeleteMarkerReplication", delete_marker_replication, f);
encode_xml("Source", source, f);
encode_xml("Destination", destination, f);
encode_xml("Filter", filter, f);
encode_xml("ID", id, f);
encode_xml("Priority", priority, f);
encode_xml("Status", status, f);
}
bool is_valid(CephContext *cct) const {
if (!is_valid_status(status)) {
ldout(cct, 5) << "NOTICE: bad status provided in rule (status=" << status << ")" << dendl;
return false;
}
if ((filter && !filter->is_valid(cct)) ||
(delete_marker_replication && !delete_marker_replication->is_valid(cct))) {
return false;
}
return true;
}
int to_sync_policy_pipe(req_state *s, rgw::sal::Driver* driver,
rgw_sync_bucket_pipes *pipe,
bool *enabled) const {
if (!is_valid(s->cct)) {
return -EINVAL;
}
pipe->id = id;
pipe->params.priority = priority;
const auto& user_id = s->user->get_id();
rgw_bucket_key dest_bk(user_id.tenant,
destination.bucket);
if (source && !source->zone_names.empty()) {
pipe->source.zones = get_zone_ids_from_names(driver, source->zone_names);
} else {
pipe->source.set_all_zones(true);
}
if (!destination.zone_names.empty()) {
pipe->dest.zones = get_zone_ids_from_names(driver, destination.zone_names);
} else {
pipe->dest.set_all_zones(true);
}
pipe->dest.bucket.emplace(dest_bk);
if (filter) {
int r = filter->to_sync_pipe_filter(s->cct, &pipe->params.source.filter);
if (r < 0) {
return r;
}
}
if (destination.acl_translation) {
rgw_user u;
u.tenant = user_id.tenant;
u.from_str(destination.acl_translation->owner); /* explicit tenant will override tenant,
otherwise will inherit it from s->user */
pipe->params.dest.acl_translation.emplace();
pipe->params.dest.acl_translation->owner = u;
}
pipe->params.dest.storage_class = destination.storage_class;
*enabled = (status == "Enabled");
pipe->params.mode = rgw_sync_pipe_params::Mode::MODE_USER;
pipe->params.user = user_id.to_str();
return 0;
}
void from_sync_policy_pipe(rgw::sal::Driver* driver,
const rgw_sync_bucket_pipes& pipe,
bool enabled) {
id = pipe.id;
status = (enabled ? "Enabled" : "Disabled");
priority = pipe.params.priority;
if (pipe.source.all_zones) {
source.reset();
} else if (pipe.source.zones) {
source.emplace();
source->zone_names = get_zone_names_from_ids(driver, *pipe.source.zones);
}
if (!pipe.dest.all_zones &&
pipe.dest.zones) {
destination.zone_names = get_zone_names_from_ids(driver, *pipe.dest.zones);
}
if (pipe.params.dest.acl_translation) {
destination.acl_translation.emplace();
destination.acl_translation->owner = pipe.params.dest.acl_translation->owner.to_str();
}
if (pipe.params.dest.storage_class) {
destination.storage_class = *pipe.params.dest.storage_class;
}
if (pipe.dest.bucket) {
destination.bucket = pipe.dest.bucket->get_key();
}
filter.emplace();
filter->from_sync_pipe_filter(pipe.params.source.filter);
if (filter->empty()) {
filter.reset();
}
}
};
std::vector<Rule> rules;
void decode_xml(XMLObj *obj) {
RGWXMLDecoder::decode_xml("Role", role, obj);
RGWXMLDecoder::decode_xml("Rule", rules, obj);
}
void dump_xml(Formatter *f) const {
encode_xml("Role", role, f);
encode_xml("Rule", rules, f);
}
int to_sync_policy_groups(req_state *s, rgw::sal::Driver* driver,
vector<rgw_sync_policy_group> *result) const {
result->resize(2);
rgw_sync_policy_group& enabled_group = (*result)[0];
rgw_sync_policy_group& disabled_group = (*result)[1];
enabled_group.id = enabled_group_id;
enabled_group.status = rgw_sync_policy_group::Status::ENABLED;
disabled_group.id = disabled_group_id;
disabled_group.status = rgw_sync_policy_group::Status::ALLOWED; /* not enabled, not forbidden */
for (auto& rule : rules) {
rgw_sync_bucket_pipes pipe;
bool enabled;
int r = rule.to_sync_policy_pipe(s, driver, &pipe, &enabled);
if (r < 0) {
ldpp_dout(s, 5) << "NOTICE: failed to convert replication configuration into sync policy pipe (rule.id=" << rule.id << "): " << cpp_strerror(-r) << dendl;
return r;
}
if (enabled) {
enabled_group.pipes.emplace_back(std::move(pipe));
} else {
disabled_group.pipes.emplace_back(std::move(pipe));
}
}
return 0;
}
void from_sync_policy_group(rgw::sal::Driver* driver,
const rgw_sync_policy_group& group) {
bool enabled = (group.status == rgw_sync_policy_group::Status::ENABLED);
for (auto& pipe : group.pipes) {
auto& rule = rules.emplace_back();
rule.from_sync_policy_pipe(driver, pipe, enabled);
}
}
};
}
void RGWGetBucketReplication_ObjStore_S3::send_response_data()
{
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
dump_start(s);
ReplicationConfiguration conf;
if (s->bucket->get_info().sync_policy) {
auto policy = s->bucket->get_info().sync_policy;
auto iter = policy->groups.find(enabled_group_id);
if (iter != policy->groups.end()) {
conf.from_sync_policy_group(driver, iter->second);
}
iter = policy->groups.find(disabled_group_id);
if (iter != policy->groups.end()) {
conf.from_sync_policy_group(driver, iter->second);
}
}
if (!op_ret) {
s->formatter->open_object_section_in_ns("ReplicationConfiguration", XMLNS_AWS_S3);
conf.dump_xml(s->formatter);
s->formatter->close_section();
rgw_flush_formatter_and_reset(s, s->formatter);
}
}
int RGWPutBucketReplication_ObjStore_S3::get_params(optional_yield y)
{
RGWXMLParser parser;
if (!parser.init()){
return -EINVAL;
}
const auto max_size = s->cct->_conf->rgw_max_put_param_size;
int r = 0;
bufferlist data;
std::tie(r, data) = read_all_input(s, max_size, false);
if (r < 0)
return r;
if (!parser.parse(data.c_str(), data.length(), 1)) {
return -ERR_MALFORMED_XML;
}
ReplicationConfiguration conf;
try {
RGWXMLDecoder::decode_xml("ReplicationConfiguration", conf, &parser);
} catch (RGWXMLDecoder::err& err) {
ldpp_dout(this, 5) << "Malformed tagging request: " << err << dendl;
return -ERR_MALFORMED_XML;
}
r = conf.to_sync_policy_groups(s, driver, &sync_policy_groups);
if (r < 0) {
return r;
}
// forward requests to meta master zone
if (!driver->is_meta_master()) {
/* only need to keep this data around if we're not meta master */
in_data = std::move(data);
}
return 0;
}
void RGWPutBucketReplication_ObjStore_S3::send_response()
{
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
dump_start(s);
}
void RGWDeleteBucketReplication_ObjStore_S3::update_sync_policy(rgw_sync_policy_info *policy)
{
policy->groups.erase(enabled_group_id);
policy->groups.erase(disabled_group_id);
}
void RGWDeleteBucketReplication_ObjStore_S3::send_response()
{
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
dump_start(s);
}
void RGWListBuckets_ObjStore_S3::send_response_begin(bool has_buckets)
{
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
dump_start(s);
// Explicitly use chunked transfer encoding so that we can stream the result
// to the user without having to wait for the full length of it.
end_header(s, NULL, to_mime_type(s->format), CHUNKED_TRANSFER_ENCODING);
if (! op_ret) {
list_all_buckets_start(s);
dump_owner(s, s->user->get_id(), s->user->get_display_name());
s->formatter->open_array_section("Buckets");
sent_data = true;
}
}
void RGWListBuckets_ObjStore_S3::send_response_data(rgw::sal::BucketList& buckets)
{
if (!sent_data)
return;
auto& m = buckets.get_buckets();
for (auto iter = m.begin(); iter != m.end(); ++iter) {
auto& bucket = iter->second;
dump_bucket(s, *bucket);
}
rgw_flush_formatter(s, s->formatter);
}
void RGWListBuckets_ObjStore_S3::send_response_end()
{
if (sent_data) {
s->formatter->close_section();
list_all_buckets_end(s);
rgw_flush_formatter_and_reset(s, s->formatter);
}
}
int RGWGetUsage_ObjStore_S3::get_params(optional_yield y)
{
start_date = s->info.args.get("start-date");
end_date = s->info.args.get("end-date");
return 0;
}
static void dump_usage_categories_info(Formatter *formatter, const rgw_usage_log_entry& entry, map<string, bool> *categories)
{
formatter->open_array_section("categories");
map<string, rgw_usage_data>::const_iterator uiter;
for (uiter = entry.usage_map.begin(); uiter != entry.usage_map.end(); ++uiter) {
if (categories && !categories->empty() && !categories->count(uiter->first))
continue;
const rgw_usage_data& usage = uiter->second;
formatter->open_object_section("Entry");
encode_json("Category", uiter->first, formatter);
encode_json("BytesSent", usage.bytes_sent, formatter);
encode_json("BytesReceived", usage.bytes_received, formatter);
encode_json("Ops", usage.ops, formatter);
encode_json("SuccessfulOps", usage.successful_ops, formatter);
formatter->close_section(); // Entry
}
formatter->close_section(); // Category
}
static void dump_usage_bucket_info(Formatter *formatter, const std::string& name, const bucket_meta_entry& entry)
{
formatter->open_object_section("Entry");
encode_json("Bucket", name, formatter);
encode_json("Bytes", entry.size, formatter);
encode_json("Bytes_Rounded", entry.size_rounded, formatter);
formatter->close_section(); // entry
}
void RGWGetUsage_ObjStore_S3::send_response()
{
if (op_ret < 0)
set_req_state_err(s, op_ret);
dump_errno(s);
// Explicitly use chunked transfer encoding so that we can stream the result
// to the user without having to wait for the full length of it.
end_header(s, this, to_mime_type(s->format), CHUNKED_TRANSFER_ENCODING);
dump_start(s);
if (op_ret < 0)
return;
Formatter *formatter = s->formatter;
string last_owner;
bool user_section_open = false;
formatter->open_object_section("Usage");
if (show_log_entries) {
formatter->open_array_section("Entries");
}
map<rgw_user_bucket, rgw_usage_log_entry>::iterator iter;
for (iter = usage.begin(); iter != usage.end(); ++iter) {
const rgw_user_bucket& ub = iter->first;
const rgw_usage_log_entry& entry = iter->second;
if (show_log_entries) {
if (ub.user.compare(last_owner) != 0) {
if (user_section_open) {
formatter->close_section();
formatter->close_section();
}
formatter->open_object_section("User");
formatter->dump_string("Owner", ub.user);
formatter->open_array_section("Buckets");
user_section_open = true;
last_owner = ub.user;
}
formatter->open_object_section("Bucket");
formatter->dump_string("Bucket", ub.bucket);
utime_t ut(entry.epoch, 0);
ut.gmtime(formatter->dump_stream("Time"));
formatter->dump_int("Epoch", entry.epoch);
dump_usage_categories_info(formatter, entry, &categories);
formatter->close_section(); // bucket
}
summary_map[ub.user].aggregate(entry, &categories);
}
if (show_log_entries) {
if (user_section_open) {
formatter->close_section(); // buckets
formatter->close_section(); //user
}
formatter->close_section(); // entries
}
if (show_log_sum) {
formatter->open_array_section("Summary");
map<string, rgw_usage_log_entry>::iterator siter;
for (siter = summary_map.begin(); siter != summary_map.end(); ++siter) {
const rgw_usage_log_entry& entry = siter->second;
formatter->open_object_section("User");
formatter->dump_string("User", siter->first);
dump_usage_categories_info(formatter, entry, &categories);
rgw_usage_data total_usage;
entry.sum(total_usage, categories);
formatter->open_object_section("Total");
encode_json("BytesSent", total_usage.bytes_sent, formatter);
encode_json("BytesReceived", total_usage.bytes_received, formatter);
encode_json("Ops", total_usage.ops, formatter);
encode_json("SuccessfulOps", total_usage.successful_ops, formatter);
formatter->close_section(); // total
formatter->close_section(); // user
}
if (s->cct->_conf->rgw_rest_getusage_op_compat) {
formatter->open_object_section("Stats");
}
// send info about quota config
auto user_info = s->user->get_info();
encode_json("QuotaMaxBytes", user_info.quota.user_quota.max_size, formatter);
encode_json("QuotaMaxBuckets", user_info.max_buckets, formatter);
encode_json("QuotaMaxObjCount", user_info.quota.user_quota.max_objects, formatter);
encode_json("QuotaMaxBytesPerBucket", user_info.quota.bucket_quota.max_objects, formatter);
encode_json("QuotaMaxObjCountPerBucket", user_info.quota.bucket_quota.max_size, formatter);
// send info about user's capacity utilization
encode_json("TotalBytes", stats.size, formatter);
encode_json("TotalBytesRounded", stats.size_rounded, formatter);
encode_json("TotalEntries", stats.num_objects, formatter);
if (s->cct->_conf->rgw_rest_getusage_op_compat) {
formatter->close_section(); //Stats
}
formatter->close_section(); // summary
}
formatter->open_array_section("CapacityUsed");
formatter->open_object_section("User");
formatter->open_array_section("Buckets");
for (const auto& biter : buckets_usage) {
const bucket_meta_entry& entry = biter.second;
dump_usage_bucket_info(formatter, biter.first, entry);
}
formatter->close_section(); // Buckets
formatter->close_section(); // User
formatter->close_section(); // CapacityUsed
formatter->close_section(); // usage
rgw_flush_formatter_and_reset(s, s->formatter);
}
int RGWListBucket_ObjStore_S3::get_common_params()
{
list_versions = s->info.args.exists("versions");
prefix = s->info.args.get("prefix");
// non-standard
s->info.args.get_bool("allow-unordered", &allow_unordered, false);
delimiter = s->info.args.get("delimiter");
max_keys = s->info.args.get("max-keys");
op_ret = parse_max_keys();
if (op_ret < 0) {
return op_ret;
}
encoding_type = s->info.args.get("encoding-type");
if (s->system_request) {
s->info.args.get_bool("objs-container", &objs_container, false);
const char *shard_id_str = s->info.env->get("HTTP_RGWX_SHARD_ID");
if (shard_id_str) {
string err;
shard_id = strict_strtol(shard_id_str, 10, &err);
if (!err.empty()) {
ldpp_dout(this, 5) << "bad shard id specified: " << shard_id_str << dendl;
return -EINVAL;
}
} else {
shard_id = s->bucket_instance_shard_id;
}
}
return 0;
}
int RGWListBucket_ObjStore_S3::get_params(optional_yield y)
{
int ret = get_common_params();
if (ret < 0) {
return ret;
}
if (!list_versions) {
marker = s->info.args.get("marker");
} else {
marker.name = s->info.args.get("key-marker");
marker.instance = s->info.args.get("version-id-marker");
}
return 0;
}
int RGWListBucket_ObjStore_S3v2::get_params(optional_yield y)
{
int ret = get_common_params();
if (ret < 0) {
return ret;
}
s->info.args.get_bool("fetch-owner", &fetchOwner, false);
startAfter = s->info.args.get("start-after", &start_after_exist);
continuation_token = s->info.args.get("continuation-token", &continuation_token_exist);
if(!continuation_token_exist) {
marker = startAfter;
} else {
marker = continuation_token;
}
return 0;
}
void RGWListBucket_ObjStore_S3::send_common_versioned_response()
{
if (!s->bucket_tenant.empty()) {
s->formatter->dump_string("Tenant", s->bucket_tenant);
}
s->formatter->dump_string("Name", s->bucket_name);
s->formatter->dump_string("Prefix", prefix);
s->formatter->dump_int("MaxKeys", max);
if (!delimiter.empty()) {
s->formatter->dump_string("Delimiter", delimiter);
}
s->formatter->dump_string("IsTruncated", (max && is_truncated ? "true"
: "false"));
if (!common_prefixes.empty()) {
map<string, bool>::iterator pref_iter;
for (pref_iter = common_prefixes.begin();
pref_iter != common_prefixes.end(); ++pref_iter) {
s->formatter->open_array_section("CommonPrefixes");
if (encode_key) {
s->formatter->dump_string("Prefix", url_encode(pref_iter->first, false));
} else {
s->formatter->dump_string("Prefix", pref_iter->first);
}
s->formatter->close_section();
}
}
}
void RGWListBucket_ObjStore_S3::send_versioned_response()
{
s->formatter->open_object_section_in_ns("ListVersionsResult", XMLNS_AWS_S3);
if (strcasecmp(encoding_type.c_str(), "url") == 0) {
s->formatter->dump_string("EncodingType", "url");
encode_key = true;
}
RGWListBucket_ObjStore_S3::send_common_versioned_response();
s->formatter->dump_string("KeyMarker", marker.name);
s->formatter->dump_string("VersionIdMarker", marker.instance);
if (is_truncated && !next_marker.empty()) {
s->formatter->dump_string("NextKeyMarker", next_marker.name);
if (next_marker.instance.empty()) {
s->formatter->dump_string("NextVersionIdMarker", "null");
}
else {
s->formatter->dump_string("NextVersionIdMarker", next_marker.instance);
}
}
if (op_ret >= 0) {
if (objs_container) {
s->formatter->open_array_section("Entries");
}
vector<rgw_bucket_dir_entry>::iterator iter;
for (iter = objs.begin(); iter != objs.end(); ++iter) {
const char *section_name = (iter->is_delete_marker() ? "DeleteMarker"
: "Version");
s->formatter->open_object_section(section_name);
if (objs_container) {
s->formatter->dump_bool("IsDeleteMarker", iter->is_delete_marker());
}
rgw_obj_key key(iter->key);
if (encode_key) {
string key_name;
url_encode(key.name, key_name);
s->formatter->dump_string("Key", key_name);
}
else {
s->formatter->dump_string("Key", key.name);
}
string version_id = key.instance;
if (version_id.empty()) {
version_id = "null";
}
if (s->system_request) {
if (iter->versioned_epoch > 0) {
s->formatter->dump_int("VersionedEpoch", iter->versioned_epoch);
}
s->formatter->dump_string("RgwxTag", iter->tag);
utime_t ut(iter->meta.mtime);
ut.gmtime_nsec(s->formatter->dump_stream("RgwxMtime"));
}
s->formatter->dump_string("VersionId", version_id);
s->formatter->dump_bool("IsLatest", iter->is_current());
dump_time(s, "LastModified", iter->meta.mtime);
if (!iter->is_delete_marker()) {
s->formatter->dump_format("ETag", "\"%s\"", iter->meta.etag.c_str());
s->formatter->dump_int("Size", iter->meta.accounted_size);
auto& storage_class = rgw_placement_rule::get_canonical_storage_class(iter->meta.storage_class);
s->formatter->dump_string("StorageClass", storage_class.c_str());
}
dump_owner(s, rgw_user(iter->meta.owner), iter->meta.owner_display_name);
if (iter->meta.appendable) {
s->formatter->dump_string("Type", "Appendable");
} else {
s->formatter->dump_string("Type", "Normal");
}
s->formatter->close_section(); // Version/DeleteMarker
}
if (objs_container) {
s->formatter->close_section(); // Entries
}
s->formatter->close_section(); // ListVersionsResult
}
rgw_flush_formatter_and_reset(s, s->formatter);
}
void RGWListBucket_ObjStore_S3::send_common_response()
{
if (!s->bucket_tenant.empty()) {
s->formatter->dump_string("Tenant", s->bucket_tenant);
}
s->formatter->dump_string("Name", s->bucket_name);
s->formatter->dump_string("Prefix", prefix);
s->formatter->dump_int("MaxKeys", max);
if (!delimiter.empty()) {
if (encode_key) {
s->formatter->dump_string("Delimiter", url_encode(delimiter, false));
} else {
s->formatter->dump_string("Delimiter", delimiter);
}
}
s->formatter->dump_string("IsTruncated", (max && is_truncated ? "true"
: "false"));
if (!common_prefixes.empty()) {
map<string, bool>::iterator pref_iter;
for (pref_iter = common_prefixes.begin();
pref_iter != common_prefixes.end(); ++pref_iter) {
s->formatter->open_array_section("CommonPrefixes");
if (encode_key) {
s->formatter->dump_string("Prefix", url_encode(pref_iter->first, false));
} else {
s->formatter->dump_string("Prefix", pref_iter->first);
}
s->formatter->close_section();
}
}
}
void RGWListBucket_ObjStore_S3::send_response()
{
if (op_ret < 0) {
set_req_state_err(s, op_ret);
}
dump_errno(s);
// Explicitly use chunked transfer encoding so that we can stream the result
// to the user without having to wait for the full length of it.
end_header(s, this, to_mime_type(s->format), CHUNKED_TRANSFER_ENCODING);
dump_start(s);
if (op_ret < 0) {
return;
}
if (list_versions) {
send_versioned_response();
return;
}
s->formatter->open_object_section_in_ns("ListBucketResult", XMLNS_AWS_S3);
if (strcasecmp(encoding_type.c_str(), "url") == 0) {
s->formatter->dump_string("EncodingType", "url");
encode_key = true;
}
RGWListBucket_ObjStore_S3::send_common_response();
if (op_ret >= 0) {
if (s->format == RGWFormat::JSON) {
s->formatter->open_array_section("Contents");
}
vector<rgw_bucket_dir_entry>::iterator iter;
for (iter = objs.begin(); iter != objs.end(); ++iter) {
rgw_obj_key key(iter->key);
std::string key_name;
if (encode_key) {
url_encode(key.name, key_name);
} else {
key_name = key.name;
}
/* conditionally format JSON in the obvious way--I'm unsure if
* AWS actually does this */
if (s->format == RGWFormat::XML) {
s->formatter->open_array_section("Contents");
} else {
// json
s->formatter->open_object_section("dummy");
}
s->formatter->dump_string("Key", key_name);
dump_time(s, "LastModified", iter->meta.mtime);
s->formatter->dump_format("ETag", "\"%s\"", iter->meta.etag.c_str());
s->formatter->dump_int("Size", iter->meta.accounted_size);
auto& storage_class = rgw_placement_rule::get_canonical_storage_class(iter->meta.storage_class);
s->formatter->dump_string("StorageClass", storage_class.c_str());
dump_owner(s, rgw_user(iter->meta.owner), iter->meta.owner_display_name);
if (s->system_request) {
s->formatter->dump_string("RgwxTag", iter->tag);
}
if (iter->meta.appendable) {
s->formatter->dump_string("Type", "Appendable");
} else {
s->formatter->dump_string("Type", "Normal");
}
// JSON has one extra section per element
s->formatter->close_section();
} // foreach obj
if (s->format == RGWFormat::JSON) {
s->formatter->close_section();
}
}
s->formatter->dump_string("Marker", marker.name);
if (is_truncated && !next_marker.empty()) {
s->formatter->dump_string("NextMarker", next_marker.name);
}
s->formatter->close_section();
rgw_flush_formatter_and_reset(s, s->formatter);
} /* RGWListBucket_ObjStore_S3::send_response() */
void RGWListBucket_ObjStore_S3v2::send_versioned_response()
{
s->formatter->open_object_section_in_ns("ListVersionsResult", XMLNS_AWS_S3);
RGWListBucket_ObjStore_S3v2::send_common_versioned_response();
s->formatter->dump_string("KeyContinuationToken", marker.name);
s->formatter->dump_string("VersionIdContinuationToken", marker.instance);
if (is_truncated && !next_marker.empty()) {
s->formatter->dump_string("NextKeyContinuationToken", next_marker.name);
s->formatter->dump_string("NextVersionIdContinuationToken", next_marker.instance);
}
if (strcasecmp(encoding_type.c_str(), "url") == 0) {
s->formatter->dump_string("EncodingType", "url");
encode_key = true;
}
if (op_ret >= 0) {
if (objs_container) {
s->formatter->open_array_section("Entries");
}
vector<rgw_bucket_dir_entry>::iterator iter;
for (iter = objs.begin(); iter != objs.end(); ++iter) {
const char *section_name = (iter->is_delete_marker() ? "DeleteContinuationToken"
: "Version");
s->formatter->open_object_section(section_name);
if (objs_container) {
s->formatter->dump_bool("IsDeleteContinuationToken", iter->is_delete_marker());
}
rgw_obj_key key(iter->key);
if (encode_key) {
string key_name;
url_encode(key.name, key_name);
s->formatter->dump_string("Key", key_name);
}
else {
s->formatter->dump_string("Key", key.name);
}
string version_id = key.instance;
if (version_id.empty()) {
version_id = "null";
}
if (s->system_request) {
if (iter->versioned_epoch > 0) {
s->formatter->dump_int("VersionedEpoch", iter->versioned_epoch);
}
s->formatter->dump_string("RgwxTag", iter->tag);
utime_t ut(iter->meta.mtime);
ut.gmtime_nsec(s->formatter->dump_stream("RgwxMtime"));
}
s->formatter->dump_string("VersionId", version_id);
s->formatter->dump_bool("IsLatest", iter->is_current());
dump_time(s, "LastModified", iter->meta.mtime);
if (!iter->is_delete_marker()) {
s->formatter->dump_format("ETag", "\"%s\"", iter->meta.etag.c_str());
s->formatter->dump_int("Size", iter->meta.accounted_size);
auto& storage_class = rgw_placement_rule::get_canonical_storage_class(iter->meta.storage_class);
s->formatter->dump_string("StorageClass", storage_class.c_str());
}
if (fetchOwner == true) {
dump_owner(s, rgw_user(iter->meta.owner), iter->meta.owner_display_name);
}
s->formatter->close_section();
}
if (objs_container) {
s->formatter->close_section();
}
if (!common_prefixes.empty()) {
map<string, bool>::iterator pref_iter;
for (pref_iter = common_prefixes.begin();
pref_iter != common_prefixes.end(); ++pref_iter) {
s->formatter->open_array_section("CommonPrefixes");
if (encode_key) {
s->formatter->dump_string("Prefix", url_encode(pref_iter->first, false));
} else {
s->formatter->dump_string("Prefix", pref_iter->first);
}
s->formatter->dump_int("KeyCount",objs.size());
if (start_after_exist) {
s->formatter->dump_string("StartAfter", startAfter);
}
s->formatter->close_section();
}
}
s->formatter->close_section();
rgw_flush_formatter_and_reset(s, s->formatter);
}
}
void RGWListBucket_ObjStore_S3v2::send_response()
{
if (op_ret < 0) {
set_req_state_err(s, op_ret);
}
dump_errno(s);
// Explicitly use chunked transfer encoding so that we can stream the result
// to the user without having to wait for the full length of it.
end_header(s, this, to_mime_type(s->format), CHUNKED_TRANSFER_ENCODING);
dump_start(s);
if (op_ret < 0) {
return;
}
if (list_versions) {
send_versioned_response();
return;
}
s->formatter->open_object_section_in_ns("ListBucketResult", XMLNS_AWS_S3);
if (strcasecmp(encoding_type.c_str(), "url") == 0) {
s->formatter->dump_string("EncodingType", "url");
encode_key = true;
}
RGWListBucket_ObjStore_S3::send_common_response();
if (op_ret >= 0) {
vector<rgw_bucket_dir_entry>::iterator iter;
for (iter = objs.begin(); iter != objs.end(); ++iter) {
rgw_obj_key key(iter->key);
s->formatter->open_array_section("Contents");
if (encode_key) {
string key_name;
url_encode(key.name, key_name);
s->formatter->dump_string("Key", key_name);
}
else {
s->formatter->dump_string("Key", key.name);
}
dump_time(s, "LastModified", iter->meta.mtime);
s->formatter->dump_format("ETag", "\"%s\"", iter->meta.etag.c_str());
s->formatter->dump_int("Size", iter->meta.accounted_size);
auto& storage_class = rgw_placement_rule::get_canonical_storage_class(iter->meta.storage_class);
s->formatter->dump_string("StorageClass", storage_class.c_str());
if (fetchOwner == true) {
dump_owner(s, rgw_user(iter->meta.owner), iter->meta.owner_display_name);
}
if (s->system_request) {
s->formatter->dump_string("RgwxTag", iter->tag);
}
if (iter->meta.appendable) {
s->formatter->dump_string("Type", "Appendable");
} else {
s->formatter->dump_string("Type", "Normal");
}
s->formatter->close_section();
}
}
if (continuation_token_exist) {
s->formatter->dump_string("ContinuationToken", continuation_token);
}
if (is_truncated && !next_marker.empty()) {
s->formatter->dump_string("NextContinuationToken", next_marker.name);
}
s->formatter->dump_int("KeyCount", objs.size() + common_prefixes.size());
if (start_after_exist) {
s->formatter->dump_string("StartAfter", startAfter);
}
s->formatter->close_section();
rgw_flush_formatter_and_reset(s, s->formatter);
}
void RGWGetBucketLogging_ObjStore_S3::send_response()
{
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
dump_start(s);
s->formatter->open_object_section_in_ns("BucketLoggingStatus", XMLNS_AWS_S3);
s->formatter->close_section();
rgw_flush_formatter_and_reset(s, s->formatter);
}
void RGWGetBucketLocation_ObjStore_S3::send_response()
{
dump_errno(s);
end_header(s, this);
dump_start(s);
std::unique_ptr<rgw::sal::ZoneGroup> zonegroup;
string api_name;
int ret = driver->get_zonegroup(s->bucket->get_info().zonegroup, &zonegroup);
if (ret >= 0) {
api_name = zonegroup->get_api_name();
} else {
if (s->bucket->get_info().zonegroup != "default") {
api_name = s->bucket->get_info().zonegroup;
}
}
s->formatter->dump_format_ns("LocationConstraint", XMLNS_AWS_S3,
"%s", api_name.c_str());
rgw_flush_formatter_and_reset(s, s->formatter);
}
void RGWGetBucketVersioning_ObjStore_S3::send_response()
{
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
dump_start(s);
s->formatter->open_object_section_in_ns("VersioningConfiguration", XMLNS_AWS_S3);
if (versioned) {
const char *status = (versioning_enabled ? "Enabled" : "Suspended");
s->formatter->dump_string("Status", status);
const char *mfa_status = (mfa_enabled ? "Enabled" : "Disabled");
s->formatter->dump_string("MfaDelete", mfa_status);
}
s->formatter->close_section();
rgw_flush_formatter_and_reset(s, s->formatter);
}
struct ver_config_status {
int status{VersioningSuspended};
enum MFAStatus {
MFA_UNKNOWN,
MFA_DISABLED,
MFA_ENABLED,
} mfa_status{MFA_UNKNOWN};
int retcode{0};
void decode_xml(XMLObj *obj) {
string status_str;
string mfa_str;
RGWXMLDecoder::decode_xml("Status", status_str, obj);
if (status_str == "Enabled") {
status = VersioningEnabled;
} else if (status_str != "Suspended") {
status = VersioningStatusInvalid;
}
if (RGWXMLDecoder::decode_xml("MfaDelete", mfa_str, obj)) {
if (mfa_str == "Enabled") {
mfa_status = MFA_ENABLED;
} else if (mfa_str == "Disabled") {
mfa_status = MFA_DISABLED;
} else {
retcode = -EINVAL;
}
}
}
};
int RGWSetBucketVersioning_ObjStore_S3::get_params(optional_yield y)
{
int r = 0;
bufferlist data;
std::tie(r, data) =
read_all_input(s, s->cct->_conf->rgw_max_put_param_size, false);
if (r < 0) {
return r;
}
RGWXMLDecoder::XMLParser parser;
if (!parser.init()) {
ldpp_dout(this, 0) << "ERROR: failed to initialize parser" << dendl;
return -EIO;
}
char* buf = data.c_str();
if (!parser.parse(buf, data.length(), 1)) {
ldpp_dout(this, 10) << "NOTICE: failed to parse data: " << buf << dendl;
r = -EINVAL;
return r;
}
ver_config_status status_conf;
if (!RGWXMLDecoder::decode_xml("VersioningConfiguration", status_conf, &parser)) {
ldpp_dout(this, 10) << "NOTICE: bad versioning config input" << dendl;
return -EINVAL;
}
if (!driver->is_meta_master()) {
/* only need to keep this data around if we're not meta master */
in_data.append(data);
}
versioning_status = status_conf.status;
if (versioning_status == VersioningStatusInvalid) {
r = -EINVAL;
}
if (status_conf.mfa_status != ver_config_status::MFA_UNKNOWN) {
mfa_set_status = true;
switch (status_conf.mfa_status) {
case ver_config_status::MFA_DISABLED:
mfa_status = false;
break;
case ver_config_status::MFA_ENABLED:
mfa_status = true;
break;
default:
ldpp_dout(this, 0) << "ERROR: RGWSetBucketVersioning_ObjStore_S3::get_params(optional_yield y): unexpected switch case mfa_status=" << status_conf.mfa_status << dendl;
r = -EIO;
}
} else if (status_conf.retcode < 0) {
r = status_conf.retcode;
}
return r;
}
void RGWSetBucketVersioning_ObjStore_S3::send_response()
{
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
}
int RGWSetBucketWebsite_ObjStore_S3::get_params(optional_yield y)
{
const auto max_size = s->cct->_conf->rgw_max_put_param_size;
int r = 0;
bufferlist data;
std::tie(r, data) = read_all_input(s, max_size, false);
if (r < 0) {
return r;
}
in_data.append(data);
RGWXMLDecoder::XMLParser parser;
if (!parser.init()) {
ldpp_dout(this, 0) << "ERROR: failed to initialize parser" << dendl;
return -EIO;
}
char* buf = data.c_str();
if (!parser.parse(buf, data.length(), 1)) {
ldpp_dout(this, 5) << "failed to parse xml: " << buf << dendl;
return -EINVAL;
}
try {
RGWXMLDecoder::decode_xml("WebsiteConfiguration", website_conf, &parser, true);
} catch (RGWXMLDecoder::err& err) {
ldpp_dout(this, 5) << "unexpected xml: " << buf << dendl;
return -EINVAL;
}
if (website_conf.is_redirect_all && website_conf.redirect_all.hostname.empty()) {
s->err.message = "A host name must be provided to redirect all requests (e.g. \"example.com\").";
ldpp_dout(this, 5) << s->err.message << dendl;
return -EINVAL;
} else if (!website_conf.is_redirect_all && !website_conf.is_set_index_doc) {
s->err.message = "A value for IndexDocument Suffix must be provided if RedirectAllRequestsTo is empty";
ldpp_dout(this, 5) << s->err.message << dendl;
return -EINVAL;
} else if (!website_conf.is_redirect_all && website_conf.is_set_index_doc &&
website_conf.index_doc_suffix.empty()) {
s->err.message = "The IndexDocument Suffix is not well formed";
ldpp_dout(this, 5) << s->err.message << dendl;
return -EINVAL;
}
#define WEBSITE_ROUTING_RULES_MAX_NUM 50
int max_num = s->cct->_conf->rgw_website_routing_rules_max_num;
if (max_num < 0) {
max_num = WEBSITE_ROUTING_RULES_MAX_NUM;
}
int routing_rules_num = website_conf.routing_rules.rules.size();
if (routing_rules_num > max_num) {
ldpp_dout(this, 4) << "An website routing config can have up to "
<< max_num
<< " rules, request website routing rules num: "
<< routing_rules_num << dendl;
op_ret = -ERR_INVALID_WEBSITE_ROUTING_RULES_ERROR;
s->err.message = std::to_string(routing_rules_num) +" routing rules provided, the number of routing rules in a website configuration is limited to "
+ std::to_string(max_num)
+ ".";
return -ERR_INVALID_REQUEST;
}
return 0;
}
void RGWSetBucketWebsite_ObjStore_S3::send_response()
{
if (op_ret < 0)
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
}
void RGWDeleteBucketWebsite_ObjStore_S3::send_response()
{
if (op_ret == 0) {
op_ret = STATUS_NO_CONTENT;
}
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
}
void RGWGetBucketWebsite_ObjStore_S3::send_response()
{
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
dump_start(s);
if (op_ret < 0) {
return;
}
RGWBucketWebsiteConf& conf = s->bucket->get_info().website_conf;
s->formatter->open_object_section_in_ns("WebsiteConfiguration", XMLNS_AWS_S3);
conf.dump_xml(s->formatter);
s->formatter->close_section(); // WebsiteConfiguration
rgw_flush_formatter_and_reset(s, s->formatter);
}
static void dump_bucket_metadata(req_state *s, rgw::sal::Bucket* bucket)
{
dump_header(s, "X-RGW-Object-Count", static_cast<long long>(bucket->get_count()));
dump_header(s, "X-RGW-Bytes-Used", static_cast<long long>(bucket->get_size()));
// only bucket's owner is allowed to get the quota settings of the account
if (bucket->is_owner(s->user.get())) {
auto user_info = s->user->get_info();
dump_header(s, "X-RGW-Quota-User-Size", static_cast<long long>(user_info.quota.user_quota.max_size));
dump_header(s, "X-RGW-Quota-User-Objects", static_cast<long long>(user_info.quota.user_quota.max_objects));
dump_header(s, "X-RGW-Quota-Max-Buckets", static_cast<long long>(user_info.max_buckets));
dump_header(s, "X-RGW-Quota-Bucket-Size", static_cast<long long>(user_info.quota.bucket_quota.max_size));
dump_header(s, "X-RGW-Quota-Bucket-Objects", static_cast<long long>(user_info.quota.bucket_quota.max_objects));
}
}
void RGWStatBucket_ObjStore_S3::send_response()
{
if (op_ret >= 0) {
dump_bucket_metadata(s, bucket.get());
}
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this);
dump_start(s);
}
static int create_s3_policy(req_state *s, rgw::sal::Driver* driver,
RGWAccessControlPolicy_S3& s3policy,
ACLOwner& owner)
{
if (s->has_acl_header) {
if (!s->canned_acl.empty())
return -ERR_INVALID_REQUEST;
return s3policy.create_from_headers(s, driver, s->info.env, owner);
}
return s3policy.create_canned(owner, s->bucket_owner, s->canned_acl);
}
class RGWLocationConstraint : public XMLObj
{
public:
RGWLocationConstraint() {}
~RGWLocationConstraint() override {}
bool xml_end(const char *el) override {
if (!el)
return false;
location_constraint = get_data();
return true;
}
string location_constraint;
};
class RGWCreateBucketConfig : public XMLObj
{
public:
RGWCreateBucketConfig() {}
~RGWCreateBucketConfig() override {}
};
class RGWCreateBucketParser : public RGWXMLParser
{
XMLObj *alloc_obj(const char *el) override {
return new XMLObj;
}
public:
RGWCreateBucketParser() {}
~RGWCreateBucketParser() override {}
bool get_location_constraint(string& zone_group) {
XMLObj *config = find_first("CreateBucketConfiguration");
if (!config)
return false;
XMLObj *constraint = config->find_first("LocationConstraint");
if (!constraint)
return false;
zone_group = constraint->get_data();
return true;
}
};
int RGWCreateBucket_ObjStore_S3::get_params(optional_yield y)
{
RGWAccessControlPolicy_S3 s3policy(s->cct);
bool relaxed_names = s->cct->_conf->rgw_relaxed_s3_bucket_names;
int r;
if (!s->system_request) {
r = valid_s3_bucket_name(s->bucket_name, relaxed_names);
if (r) return r;
}
r = create_s3_policy(s, driver, s3policy, s->owner);
if (r < 0)
return r;
policy = s3policy;
const auto max_size = s->cct->_conf->rgw_max_put_param_size;
int op_ret = 0;
bufferlist data;
std::tie(op_ret, data) = read_all_input(s, max_size, false);
if ((op_ret < 0) && (op_ret != -ERR_LENGTH_REQUIRED))
return op_ret;
in_data.append(data);
if (data.length()) {
RGWCreateBucketParser parser;
if (!parser.init()) {
ldpp_dout(this, 0) << "ERROR: failed to initialize parser" << dendl;
return -EIO;
}
char* buf = data.c_str();
bool success = parser.parse(buf, data.length(), 1);
ldpp_dout(this, 20) << "create bucket input data=" << buf << dendl;
if (!success) {
ldpp_dout(this, 0) << "failed to parse input: " << buf << dendl;
return -EINVAL;
}
if (!parser.get_location_constraint(location_constraint)) {
ldpp_dout(this, 0) << "provided input did not specify location constraint correctly" << dendl;
return -EINVAL;
}
ldpp_dout(this, 10) << "create bucket location constraint: "
<< location_constraint << dendl;
}
size_t pos = location_constraint.find(':');
if (pos != string::npos) {
placement_rule.init(location_constraint.substr(pos + 1), s->info.storage_class);
location_constraint = location_constraint.substr(0, pos);
} else {
placement_rule.storage_class = s->info.storage_class;
}
auto iter = s->info.x_meta_map.find("x-amz-bucket-object-lock-enabled");
if (iter != s->info.x_meta_map.end()) {
if (!boost::algorithm::iequals(iter->second, "true") && !boost::algorithm::iequals(iter->second, "false")) {
return -EINVAL;
}
obj_lock_enabled = boost::algorithm::iequals(iter->second, "true");
}
return 0;
}
void RGWCreateBucket_ObjStore_S3::send_response()
{
if (op_ret == -ERR_BUCKET_EXISTS)
op_ret = 0;
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s);
if (op_ret < 0)
return;
if (s->system_request) {
JSONFormatter f; /* use json formatter for system requests output */
f.open_object_section("info");
encode_json("entry_point_object_ver", ep_objv, &f);
encode_json("object_ver", info.objv_tracker.read_version, &f);
encode_json("bucket_info", info, &f);
f.close_section();
rgw_flush_formatter_and_reset(s, &f);
}
}
void RGWDeleteBucket_ObjStore_S3::send_response()
{
int r = op_ret;
if (!r)
r = STATUS_NO_CONTENT;
set_req_state_err(s, r);
dump_errno(s);
end_header(s, this);
}
static inline void map_qs_metadata(req_state* s, bool crypto_too)
{
/* merge S3 valid user metadata from the query-string into
* x_meta_map, which maps them to attributes */
const auto& params = const_cast<RGWHTTPArgs&>(s->info.args).get_params();
for (const auto& elt : params) {
std::string k = boost::algorithm::to_lower_copy(elt.first);
if (k.find("x-amz-meta-") == /* offset */ 0) {
rgw_add_amz_meta_header(s->info.x_meta_map, k, elt.second);
}
if (crypto_too && k.find("x-amz-server-side-encryption") == /* offset */ 0) {
rgw_set_amz_meta_header(s->info.crypt_attribute_map, k, elt.second, OVERWRITE);
}
}
}
int RGWPutObj_ObjStore_S3::get_params(optional_yield y)
{
if (!s->length) {
const char *encoding = s->info.env->get("HTTP_TRANSFER_ENCODING");
if (!encoding || strcmp(encoding, "chunked") != 0) {
ldout(s->cct, 20) << "neither length nor chunked encoding" << dendl;
return -ERR_LENGTH_REQUIRED;
}
chunked_upload = true;
}
int ret;
map_qs_metadata(s, true);
ret = get_encryption_defaults(s);
if (ret < 0) {
ldpp_dout(this, 5) << __func__ << "(): get_encryption_defaults() returned ret=" << ret << dendl;
return ret;
}
RGWAccessControlPolicy_S3 s3policy(s->cct);
ret = create_s3_policy(s, driver, s3policy, s->owner);
if (ret < 0)
return ret;
policy = s3policy;
if_match = s->info.env->get("HTTP_IF_MATCH");
if_nomatch = s->info.env->get("HTTP_IF_NONE_MATCH");
/* handle object tagging */
auto tag_str = s->info.env->get("HTTP_X_AMZ_TAGGING");
if (tag_str){
obj_tags = std::make_unique<RGWObjTags>();
ret = obj_tags->set_from_string(tag_str);
if (ret < 0){
ldpp_dout(this,0) << "setting obj tags failed with " << ret << dendl;
if (ret == -ERR_INVALID_TAG){
ret = -EINVAL; //s3 returns only -EINVAL for PUT requests
}
return ret;
}
}
//handle object lock
auto obj_lock_mode_str = s->info.env->get("HTTP_X_AMZ_OBJECT_LOCK_MODE");
auto obj_lock_date_str = s->info.env->get("HTTP_X_AMZ_OBJECT_LOCK_RETAIN_UNTIL_DATE");
auto obj_legal_hold_str = s->info.env->get("HTTP_X_AMZ_OBJECT_LOCK_LEGAL_HOLD");
if (obj_lock_mode_str && obj_lock_date_str) {
boost::optional<ceph::real_time> date = ceph::from_iso_8601(obj_lock_date_str);
if (boost::none == date || ceph::real_clock::to_time_t(*date) <= ceph_clock_now()) {
ret = -EINVAL;
ldpp_dout(this,0) << "invalid x-amz-object-lock-retain-until-date value" << dendl;
return ret;
}
if (strcmp(obj_lock_mode_str, "GOVERNANCE") != 0 && strcmp(obj_lock_mode_str, "COMPLIANCE") != 0) {
ret = -EINVAL;
ldpp_dout(this,0) << "invalid x-amz-object-lock-mode value" << dendl;
return ret;
}
obj_retention = new RGWObjectRetention(obj_lock_mode_str, *date);
} else if ((obj_lock_mode_str && !obj_lock_date_str) || (!obj_lock_mode_str && obj_lock_date_str)) {
ret = -EINVAL;
ldpp_dout(this,0) << "need both x-amz-object-lock-mode and x-amz-object-lock-retain-until-date " << dendl;
return ret;
}
if (obj_legal_hold_str) {
if (strcmp(obj_legal_hold_str, "ON") != 0 && strcmp(obj_legal_hold_str, "OFF") != 0) {
ret = -EINVAL;
ldpp_dout(this,0) << "invalid x-amz-object-lock-legal-hold value" << dendl;
return ret;
}
obj_legal_hold = new RGWObjectLegalHold(obj_legal_hold_str);
}
if (!s->bucket->get_info().obj_lock_enabled() && (obj_retention || obj_legal_hold)) {
ldpp_dout(this, 0) << "ERROR: object retention or legal hold can't be set if bucket object lock not configured" << dendl;
ret = -ERR_INVALID_REQUEST;
return ret;
}
multipart_upload_id = s->info.args.get("uploadId");
multipart_part_str = s->info.args.get("partNumber");
if (!multipart_part_str.empty()) {
string err;
multipart_part_num = strict_strtol(multipart_part_str.c_str(), 10, &err);
if (!err.empty()) {
ldpp_dout(s, 10) << "bad part number: " << multipart_part_str << ": " << err << dendl;
return -EINVAL;
}
} else if (!multipart_upload_id.empty()) {
ldpp_dout(s, 10) << "part number with no multipart upload id" << dendl;
return -EINVAL;
}
append = s->info.args.exists("append");
if (append) {
string pos_str = s->info.args.get("position");
string err;
long long pos_tmp = strict_strtoll(pos_str.c_str(), 10, &err);
if (!err.empty()) {
ldpp_dout(s, 10) << "bad position: " << pos_str << ": " << err << dendl;
return -EINVAL;
} else if (pos_tmp < 0) {
ldpp_dout(s, 10) << "bad position: " << pos_str << ": " << "position shouldn't be negative" << dendl;
return -EINVAL;
}
position = uint64_t(pos_tmp);
}
return RGWPutObj_ObjStore::get_params(y);
}
int RGWPutObj_ObjStore_S3::get_data(bufferlist& bl)
{
const int ret = RGWPutObj_ObjStore::get_data(bl);
if (ret == 0) {
const int ret_auth = do_aws4_auth_completion();
if (ret_auth < 0) {
return ret_auth;
}
}
return ret;
}
static int get_success_retcode(int code)
{
switch (code) {
case 201:
return STATUS_CREATED;
case 204:
return STATUS_NO_CONTENT;
}
return 0;
}
void RGWPutObj_ObjStore_S3::send_response()
{
if (op_ret) {
set_req_state_err(s, op_ret);
dump_errno(s);
} else {
if (s->cct->_conf->rgw_s3_success_create_obj_status) {
op_ret = get_success_retcode(
s->cct->_conf->rgw_s3_success_create_obj_status);
set_req_state_err(s, op_ret);
}
string expires = get_s3_expiration_header(s, mtime);
if (copy_source.empty()) {
dump_errno(s);
dump_etag(s, etag);
dump_content_length(s, 0);
dump_header_if_nonempty(s, "x-amz-version-id", version_id);
dump_header_if_nonempty(s, "x-amz-expiration", expires);
for (auto &it : crypt_http_responses)
dump_header(s, it.first, it.second);
} else {
dump_errno(s);
dump_header_if_nonempty(s, "x-amz-version-id", version_id);
dump_header_if_nonempty(s, "x-amz-expiration", expires);
end_header(s, this, to_mime_type(s->format));
dump_start(s);
struct tm tmp;
utime_t ut(mtime);
time_t secs = (time_t)ut.sec();
gmtime_r(&secs, &tmp);
char buf[TIME_BUF_SIZE];
s->formatter->open_object_section_in_ns("CopyPartResult",
"http://s3.amazonaws.com/doc/2006-03-01/");
if (strftime(buf, sizeof(buf), "%Y-%m-%dT%T.000Z", &tmp) > 0) {
s->formatter->dump_string("LastModified", buf);
}
s->formatter->dump_string("ETag", etag);
s->formatter->close_section();
rgw_flush_formatter_and_reset(s, s->formatter);
return;
}
}
if (append) {
if (op_ret == 0 || op_ret == -ERR_POSITION_NOT_EQUAL_TO_LENGTH) {
dump_header(s, "x-rgw-next-append-position", cur_accounted_size);
}
}
if (s->system_request && !real_clock::is_zero(mtime)) {
dump_epoch_header(s, "Rgwx-Mtime", mtime);
}
end_header(s, this);
}
static inline void set_attr(map<string, bufferlist>& attrs, const char* key, const std::string& value)
{
bufferlist bl;
encode(value,bl);
attrs.emplace(key, std::move(bl));
}
static inline void set_attr(map<string, bufferlist>& attrs, const char* key, const char* value)
{
bufferlist bl;
encode(value,bl);
attrs.emplace(key, std::move(bl));
}
int RGWPutObj_ObjStore_S3::get_decrypt_filter(
std::unique_ptr<RGWGetObj_Filter>* filter,
RGWGetObj_Filter* cb,
map<string, bufferlist>& attrs,
bufferlist* manifest_bl)
{
std::map<std::string, std::string> crypt_http_responses_unused;
int res = 0;
std::unique_ptr<BlockCrypt> block_crypt;
res = rgw_s3_prepare_decrypt(s, attrs, &block_crypt, crypt_http_responses_unused);
if (res == 0) {
if (block_crypt != nullptr) {
auto f = std::unique_ptr<RGWGetObj_BlockDecrypt>(new RGWGetObj_BlockDecrypt(s, s->cct, cb, std::move(block_crypt), s->yield));
if (f != nullptr) {
if (manifest_bl != nullptr) {
res = f->read_manifest(this, *manifest_bl);
if (res == 0) {
*filter = std::move(f);
}
}
}
}
}
return res;
}
int RGWPutObj_ObjStore_S3::get_encrypt_filter(
std::unique_ptr<rgw::sal::DataProcessor> *filter,
rgw::sal::DataProcessor *cb)
{
int res = 0;
if (!multipart_upload_id.empty()) {
std::unique_ptr<rgw::sal::MultipartUpload> upload =
s->bucket->get_multipart_upload(s->object->get_name(),
multipart_upload_id);
std::unique_ptr<rgw::sal::Object> obj = upload->get_meta_obj();
obj->set_in_extra_data(true);
res = obj->get_obj_attrs(s->yield, this);
if (res == 0) {
std::unique_ptr<BlockCrypt> block_crypt;
/* We are adding to existing object.
* We use crypto mode that configured as if we were decrypting. */
res = rgw_s3_prepare_decrypt(s, obj->get_attrs(), &block_crypt, crypt_http_responses);
if (res == 0 && block_crypt != nullptr)
filter->reset(new RGWPutObj_BlockEncrypt(s, s->cct, cb, std::move(block_crypt), s->yield));
}
/* it is ok, to not have encryption at all */
}
else
{
std::unique_ptr<BlockCrypt> block_crypt;
res = rgw_s3_prepare_encrypt(s, attrs, &block_crypt, crypt_http_responses);
if (res == 0 && block_crypt != nullptr) {
filter->reset(new RGWPutObj_BlockEncrypt(s, s->cct, cb, std::move(block_crypt), s->yield));
}
}
return res;
}
void RGWPostObj_ObjStore_S3::rebuild_key(rgw::sal::Object* obj)
{
string key = obj->get_name();
static string var = "${filename}";
int pos = key.find(var);
if (pos < 0)
return;
string new_key = key.substr(0, pos);
new_key.append(filename);
new_key.append(key.substr(pos + var.size()));
obj->set_key(new_key);
}
std::string RGWPostObj_ObjStore_S3::get_current_filename() const
{
return s->object->get_name();
}
std::string RGWPostObj_ObjStore_S3::get_current_content_type() const
{
return content_type;
}
int RGWPostObj_ObjStore_S3::get_params(optional_yield y)
{
op_ret = RGWPostObj_ObjStore::get_params(y);
if (op_ret < 0) {
return op_ret;
}
map_qs_metadata(s, false);
ldpp_dout(this, 20) << "adding bucket to policy env: " << s->bucket->get_name()
<< dendl;
env.add_var("bucket", s->bucket->get_name());
bool done;
do {
struct post_form_part part;
int r = read_form_part_header(&part, done);
if (r < 0)
return r;
if (s->cct->_conf->subsys.should_gather<ceph_subsys_rgw, 20>()) {
ldpp_dout(this, 20) << "read part header -- part.name="
<< part.name << dendl;
for (const auto& pair : part.fields) {
ldpp_dout(this, 20) << "field.name=" << pair.first << dendl;
ldpp_dout(this, 20) << "field.val=" << pair.second.val << dendl;
ldpp_dout(this, 20) << "field.params:" << dendl;
for (const auto& param_pair : pair.second.params) {
ldpp_dout(this, 20) << " " << param_pair.first
<< " -> " << param_pair.second << dendl;
}
}
}
if (done) { /* unexpected here */
err_msg = "Malformed request";
return -EINVAL;
}
if (stringcasecmp(part.name, "file") == 0) { /* beginning of data transfer */
struct post_part_field& field = part.fields["Content-Disposition"];
map<string, string>::iterator iter = field.params.find("filename");
if (iter != field.params.end()) {
filename = iter->second;
}
parts[part.name] = part;
break;
}
bool boundary;
uint64_t chunk_size = s->cct->_conf->rgw_max_chunk_size;
r = read_data(part.data, chunk_size, boundary, done);
if (r < 0 || !boundary) {
err_msg = "Couldn't find boundary";
return -EINVAL;
}
parts[part.name] = part;
string part_str(part.data.c_str(), part.data.length());
env.add_var(part.name, part_str);
} while (!done);
for (auto &p: parts) {
if (! boost::istarts_with(p.first, "x-amz-server-side-encryption")) {
continue;
}
bufferlist &d { p.second.data };
std::string v { rgw_trim_whitespace(std::string_view(d.c_str(), d.length())) };
rgw_set_amz_meta_header(s->info.crypt_attribute_map, p.first, v, OVERWRITE);
}
int r = get_encryption_defaults(s);
if (r < 0) {
ldpp_dout(this, 5) << __func__ << "(): get_encryption_defaults() returned ret=" << r << dendl;
return r;
}
string object_str;
if (!part_str(parts, "key", &object_str)) {
err_msg = "Key not specified";
return -EINVAL;
}
s->object = s->bucket->get_object(rgw_obj_key(object_str));
rebuild_key(s->object.get());
if (rgw::sal::Object::empty(s->object.get())) {
err_msg = "Empty object name";
return -EINVAL;
}
env.add_var("key", s->object->get_name());
part_str(parts, "Content-Type", &content_type);
/* AWS permits POST without Content-Type: http://tracker.ceph.com/issues/20201 */
if (! content_type.empty()) {
env.add_var("Content-Type", content_type);
}
std::string storage_class;
part_str(parts, "x-amz-storage-class", &storage_class);
if (! storage_class.empty()) {
s->dest_placement.storage_class = storage_class;
if (!driver->valid_placement(s->dest_placement)) {
ldpp_dout(this, 0) << "NOTICE: invalid dest placement: " << s->dest_placement.to_str() << dendl;
err_msg = "The storage class you specified is not valid";
return -EINVAL;
}
}
map<string, struct post_form_part, ltstr_nocase>::iterator piter =
parts.upper_bound(RGW_AMZ_META_PREFIX);
for (; piter != parts.end(); ++piter) {
string n = piter->first;
if (strncasecmp(n.c_str(), RGW_AMZ_META_PREFIX,
sizeof(RGW_AMZ_META_PREFIX) - 1) != 0)
break;
string attr_name = RGW_ATTR_PREFIX;
attr_name.append(n);
/* need to null terminate it */
bufferlist& data = piter->second.data;
string str = string(data.c_str(), data.length());
bufferlist attr_bl;
attr_bl.append(str.c_str(), str.size() + 1);
attrs[attr_name] = attr_bl;
}
// TODO: refactor this and the above loop to share code
piter = parts.find(RGW_AMZ_WEBSITE_REDIRECT_LOCATION);
if (piter != parts.end()) {
string n = piter->first;
string attr_name = RGW_ATTR_PREFIX;
attr_name.append(n);
/* need to null terminate it */
bufferlist& data = piter->second.data;
string str = string(data.c_str(), data.length());
bufferlist attr_bl;
attr_bl.append(str.c_str(), str.size() + 1);
attrs[attr_name] = attr_bl;
}
r = get_policy(y);
if (r < 0)
return r;
r = get_tags();
if (r < 0)
return r;
min_len = post_policy.min_length;
max_len = post_policy.max_length;
return 0;
}
int RGWPostObj_ObjStore_S3::get_tags()
{
string tags_str;
if (part_str(parts, "tagging", &tags_str)) {
RGWXMLParser parser;
if (!parser.init()){
ldpp_dout(this, 0) << "Couldn't init RGWObjTags XML parser" << dendl;
err_msg = "Server couldn't process the request";
return -EINVAL; // TODO: This class of errors in rgw code should be a 5XX error
}
if (!parser.parse(tags_str.c_str(), tags_str.size(), 1)) {
ldpp_dout(this,0 ) << "Invalid Tagging XML" << dendl;
err_msg = "Invalid Tagging XML";
return -EINVAL;
}
RGWObjTagging_S3 tagging;
try {
RGWXMLDecoder::decode_xml("Tagging", tagging, &parser);
} catch (RGWXMLDecoder::err& err) {
ldpp_dout(this, 5) << "Malformed tagging request: " << err << dendl;
return -EINVAL;
}
RGWObjTags obj_tags;
int r = tagging.rebuild(obj_tags);
if (r < 0)
return r;
bufferlist tags_bl;
obj_tags.encode(tags_bl);
ldpp_dout(this, 20) << "Read " << obj_tags.count() << "tags" << dendl;
attrs[RGW_ATTR_TAGS] = tags_bl;
}
return 0;
}
int RGWPostObj_ObjStore_S3::get_policy(optional_yield y)
{
if (part_bl(parts, "policy", &s->auth.s3_postobj_creds.encoded_policy)) {
bool aws4_auth = false;
/* x-amz-algorithm handling */
using rgw::auth::s3::AWS4_HMAC_SHA256_STR;
if ((part_str(parts, "x-amz-algorithm", &s->auth.s3_postobj_creds.x_amz_algorithm)) &&
(s->auth.s3_postobj_creds.x_amz_algorithm == AWS4_HMAC_SHA256_STR)) {
ldpp_dout(this, 0) << "Signature verification algorithm AWS v4 (AWS4-HMAC-SHA256)" << dendl;
aws4_auth = true;
} else {
ldpp_dout(this, 0) << "Signature verification algorithm AWS v2" << dendl;
}
// check that the signature matches the encoded policy
if (aws4_auth) {
/* AWS4 */
/* x-amz-credential handling */
if (!part_str(parts, "x-amz-credential",
&s->auth.s3_postobj_creds.x_amz_credential)) {
ldpp_dout(this, 0) << "No S3 aws4 credential found!" << dendl;
err_msg = "Missing aws4 credential";
return -EINVAL;
}
/* x-amz-signature handling */
if (!part_str(parts, "x-amz-signature",
&s->auth.s3_postobj_creds.signature)) {
ldpp_dout(this, 0) << "No aws4 signature found!" << dendl;
err_msg = "Missing aws4 signature";
return -EINVAL;
}
/* x-amz-date handling */
std::string received_date_str;
if (!part_str(parts, "x-amz-date", &received_date_str)) {
ldpp_dout(this, 0) << "No aws4 date found!" << dendl;
err_msg = "Missing aws4 date";
return -EINVAL;
}
} else {
/* AWS2 */
// check that the signature matches the encoded policy
if (!part_str(parts, "AWSAccessKeyId",
&s->auth.s3_postobj_creds.access_key)) {
ldpp_dout(this, 0) << "No S3 aws2 access key found!" << dendl;
err_msg = "Missing aws2 access key";
return -EINVAL;
}
if (!part_str(parts, "signature", &s->auth.s3_postobj_creds.signature)) {
ldpp_dout(this, 0) << "No aws2 signature found!" << dendl;
err_msg = "Missing aws2 signature";
return -EINVAL;
}
}
if (part_str(parts, "x-amz-security-token", &s->auth.s3_postobj_creds.x_amz_security_token)) {
if (s->auth.s3_postobj_creds.x_amz_security_token.size() == 0) {
err_msg = "Invalid token";
return -EINVAL;
}
}
/* FIXME: this is a makeshift solution. The browser upload authentication will be
* handled by an instance of rgw::auth::Completer spawned in Handler's authorize()
* method. */
const int ret = rgw::auth::Strategy::apply(this, auth_registry_ptr->get_s3_post(), s, y);
if (ret != 0) {
return -EACCES;
} else {
/* Populate the owner info. */
s->owner.set_id(s->user->get_id());
s->owner.set_name(s->user->get_display_name());
ldpp_dout(this, 20) << "Successful Signature Verification!" << dendl;
}
ceph::bufferlist decoded_policy;
try {
decoded_policy.decode_base64(s->auth.s3_postobj_creds.encoded_policy);
} catch (buffer::error& err) {
ldpp_dout(this, 0) << "failed to decode_base64 policy" << dendl;
err_msg = "Could not decode policy";
return -EINVAL;
}
decoded_policy.append('\0'); // NULL terminate
ldpp_dout(this, 20) << "POST policy: " << decoded_policy.c_str() << dendl;
int r = post_policy.from_json(decoded_policy, err_msg);
if (r < 0) {
if (err_msg.empty()) {
err_msg = "Failed to parse policy";
}
ldpp_dout(this, 0) << "failed to parse policy" << dendl;
return -EINVAL;
}
if (aws4_auth) {
/* AWS4 */
post_policy.set_var_checked("x-amz-signature");
} else {
/* AWS2 */
post_policy.set_var_checked("AWSAccessKeyId");
post_policy.set_var_checked("signature");
}
post_policy.set_var_checked("policy");
r = post_policy.check(&env, err_msg);
if (r < 0) {
if (err_msg.empty()) {
err_msg = "Policy check failed";
}
ldpp_dout(this, 0) << "policy check failed" << dendl;
return r;
}
} else {
ldpp_dout(this, 0) << "No attached policy found!" << dendl;
}
string canned_acl;
part_str(parts, "acl", &canned_acl);
RGWAccessControlPolicy_S3 s3policy(s->cct);
ldpp_dout(this, 20) << "canned_acl=" << canned_acl << dendl;
if (s3policy.create_canned(s->owner, s->bucket_owner, canned_acl) < 0) {
err_msg = "Bad canned ACLs";
return -EINVAL;
}
policy = s3policy;
return 0;
}
int RGWPostObj_ObjStore_S3::complete_get_params()
{
bool done;
do {
struct post_form_part part;
int r = read_form_part_header(&part, done);
if (r < 0) {
return r;
}
ceph::bufferlist part_data;
bool boundary;
uint64_t chunk_size = s->cct->_conf->rgw_max_chunk_size;
r = read_data(part.data, chunk_size, boundary, done);
if (r < 0 || !boundary) {
return -EINVAL;
}
/* Just reading the data but not storing any results of that. */
} while (!done);
return 0;
}
int RGWPostObj_ObjStore_S3::get_data(ceph::bufferlist& bl, bool& again)
{
bool boundary;
bool done;
const uint64_t chunk_size = s->cct->_conf->rgw_max_chunk_size;
int r = read_data(bl, chunk_size, boundary, done);
if (r < 0) {
return r;
}
if (boundary) {
if (!done) {
/* Reached end of data, let's drain the rest of the params */
r = complete_get_params();
if (r < 0) {
return r;
}
}
}
again = !boundary;
return bl.length();
}
void RGWPostObj_ObjStore_S3::send_response()
{
if (op_ret == 0 && parts.count("success_action_redirect")) {
string redirect;
part_str(parts, "success_action_redirect", &redirect);
string tenant;
string bucket;
string key;
string etag_str = "\"";
etag_str.append(etag);
etag_str.append("\"");
string etag_url;
url_encode(s->bucket_tenant, tenant); /* surely overkill, but cheap */
url_encode(s->bucket_name, bucket);
url_encode(s->object->get_name(), key);
url_encode(etag_str, etag_url);
if (!s->bucket_tenant.empty()) {
/*
* What we really would like is to quaily the bucket name, so
* that the client could simply copy it and paste into next request.
* Unfortunately, in S3 we cannot know if the client will decide
* to come through DNS, with "bucket.tenant" sytanx, or through
* URL with "tenant\bucket" syntax. Therefore, we provide the
* tenant separately.
*/
redirect.append("?tenant=");
redirect.append(tenant);
redirect.append("&bucket=");
redirect.append(bucket);
} else {
redirect.append("?bucket=");
redirect.append(bucket);
}
redirect.append("&key=");
redirect.append(key);
redirect.append("&etag=");
redirect.append(etag_url);
int r = check_utf8(redirect.c_str(), redirect.size());
if (r < 0) {
op_ret = r;
goto done;
}
dump_redirect(s, redirect);
op_ret = STATUS_REDIRECT;
} else if (op_ret == 0 && parts.count("success_action_status")) {
string status_string;
uint32_t status_int;
part_str(parts, "success_action_status", &status_string);
int r = stringtoul(status_string, &status_int);
if (r < 0) {
op_ret = r;
goto done;
}
switch (status_int) {
case 200:
break;
case 201:
op_ret = STATUS_CREATED;
break;
default:
op_ret = STATUS_NO_CONTENT;
break;
}
} else if (! op_ret) {
op_ret = STATUS_NO_CONTENT;
}
done:
if (op_ret == STATUS_CREATED) {
for (auto &it : crypt_http_responses)
dump_header(s, it.first, it.second);
s->formatter->open_object_section("PostResponse");
std::string base_uri = compute_domain_uri(s);
if (!s->bucket_tenant.empty()){
s->formatter->dump_format("Location", "%s/%s:%s/%s",
base_uri.c_str(),
url_encode(s->bucket_tenant).c_str(),
url_encode(s->bucket_name).c_str(),
url_encode(s->object->get_name()).c_str());
s->formatter->dump_string("Tenant", s->bucket_tenant);
} else {
s->formatter->dump_format("Location", "%s/%s/%s",
base_uri.c_str(),
url_encode(s->bucket_name).c_str(),
url_encode(s->object->get_name()).c_str());
}
s->formatter->dump_string("Bucket", s->bucket_name);
s->formatter->dump_string("Key", s->object->get_name());
s->formatter->dump_string("ETag", etag);
s->formatter->close_section();
}
s->err.message = err_msg;
set_req_state_err(s, op_ret);
dump_errno(s);
if (op_ret >= 0) {
dump_content_length(s, s->formatter->get_len());
}
end_header(s, this);
if (op_ret != STATUS_CREATED)
return;
rgw_flush_formatter_and_reset(s, s->formatter);
}
int RGWPostObj_ObjStore_S3::get_encrypt_filter(
std::unique_ptr<rgw::sal::DataProcessor> *filter,
rgw::sal::DataProcessor *cb)
{
std::unique_ptr<BlockCrypt> block_crypt;
int res = rgw_s3_prepare_encrypt(s, attrs, &block_crypt,
crypt_http_responses);
if (res == 0 && block_crypt != nullptr) {
filter->reset(new RGWPutObj_BlockEncrypt(s, s->cct, cb, std::move(block_crypt), s->yield));
}
return res;
}
int RGWDeleteObj_ObjStore_S3::get_params(optional_yield y)
{
const char *if_unmod = s->info.env->get("HTTP_X_AMZ_DELETE_IF_UNMODIFIED_SINCE");
if (s->system_request) {
s->info.args.get_bool(RGW_SYS_PARAM_PREFIX "no-precondition-error", &no_precondition_error, false);
}
if (if_unmod) {
std::string if_unmod_decoded = url_decode(if_unmod);
uint64_t epoch;
uint64_t nsec;
if (utime_t::parse_date(if_unmod_decoded, &epoch, &nsec) < 0) {
ldpp_dout(this, 10) << "failed to parse time: " << if_unmod_decoded << dendl;
return -EINVAL;
}
unmod_since = utime_t(epoch, nsec).to_real_time();
}
const char *bypass_gov_header = s->info.env->get("HTTP_X_AMZ_BYPASS_GOVERNANCE_RETENTION");
if (bypass_gov_header) {
std::string bypass_gov_decoded = url_decode(bypass_gov_header);
bypass_governance_mode = boost::algorithm::iequals(bypass_gov_decoded, "true");
}
return 0;
}
void RGWDeleteObj_ObjStore_S3::send_response()
{
int r = op_ret;
if (r == -ENOENT)
r = 0;
if (!r)
r = STATUS_NO_CONTENT;
set_req_state_err(s, r);
dump_errno(s);
dump_header_if_nonempty(s, "x-amz-version-id", version_id);
if (delete_marker) {
dump_header(s, "x-amz-delete-marker", "true");
}
end_header(s, this);
}
int RGWCopyObj_ObjStore_S3::init_dest_policy()
{
RGWAccessControlPolicy_S3 s3policy(s->cct);
/* build a policy for the target object */
int r = create_s3_policy(s, driver, s3policy, s->owner);
if (r < 0)
return r;
dest_policy = s3policy;
return 0;
}
int RGWCopyObj_ObjStore_S3::get_params(optional_yield y)
{
//handle object lock
auto obj_lock_mode_str = s->info.env->get("HTTP_X_AMZ_OBJECT_LOCK_MODE");
auto obj_lock_date_str = s->info.env->get("HTTP_X_AMZ_OBJECT_LOCK_RETAIN_UNTIL_DATE");
auto obj_legal_hold_str = s->info.env->get("HTTP_X_AMZ_OBJECT_LOCK_LEGAL_HOLD");
if (obj_lock_mode_str && obj_lock_date_str) {
boost::optional<ceph::real_time> date = ceph::from_iso_8601(obj_lock_date_str);
if (boost::none == date || ceph::real_clock::to_time_t(*date) <= ceph_clock_now()) {
s->err.message = "invalid x-amz-object-lock-retain-until-date value";
ldpp_dout(this,0) << s->err.message << dendl;
return -EINVAL;
}
if (strcmp(obj_lock_mode_str, "GOVERNANCE") != 0 && strcmp(obj_lock_mode_str, "COMPLIANCE") != 0) {
s->err.message = "invalid x-amz-object-lock-mode value";
ldpp_dout(this,0) << s->err.message << dendl;
return -EINVAL;
}
obj_retention = new RGWObjectRetention(obj_lock_mode_str, *date);
} else if (obj_lock_mode_str || obj_lock_date_str) {
s->err.message = "need both x-amz-object-lock-mode and x-amz-object-lock-retain-until-date ";
ldpp_dout(this,0) << s->err.message << dendl;
return -EINVAL;
}
if (obj_legal_hold_str) {
if (strcmp(obj_legal_hold_str, "ON") != 0 && strcmp(obj_legal_hold_str, "OFF") != 0) {
s->err.message = "invalid x-amz-object-lock-legal-hold value";
ldpp_dout(this,0) << s->err.message << dendl;
return -EINVAL;
}
obj_legal_hold = new RGWObjectLegalHold(obj_legal_hold_str);
}
if_mod = s->info.env->get("HTTP_X_AMZ_COPY_SOURCE_IF_MODIFIED_SINCE");
if_unmod = s->info.env->get("HTTP_X_AMZ_COPY_SOURCE_IF_UNMODIFIED_SINCE");
if_match = s->info.env->get("HTTP_X_AMZ_COPY_SOURCE_IF_MATCH");
if_nomatch = s->info.env->get("HTTP_X_AMZ_COPY_SOURCE_IF_NONE_MATCH");
if (s->system_request) {
source_zone = s->info.args.get(RGW_SYS_PARAM_PREFIX "source-zone");
s->info.args.get_bool(RGW_SYS_PARAM_PREFIX "copy-if-newer", ©_if_newer, false);
}
const char *copy_source_temp = s->info.env->get("HTTP_X_AMZ_COPY_SOURCE");
if (copy_source_temp) {
copy_source = copy_source_temp;
}
auto tmp_md_d = s->info.env->get("HTTP_X_AMZ_METADATA_DIRECTIVE");
if (tmp_md_d) {
if (strcasecmp(tmp_md_d, "COPY") == 0) {
attrs_mod = rgw::sal::ATTRSMOD_NONE;
} else if (strcasecmp(tmp_md_d, "REPLACE") == 0) {
attrs_mod = rgw::sal::ATTRSMOD_REPLACE;
} else if (!source_zone.empty()) {
attrs_mod = rgw::sal::ATTRSMOD_NONE; // default for intra-zone_group copy
} else {
s->err.message = "Unknown metadata directive.";
ldpp_dout(this, 0) << s->err.message << dendl;
return -EINVAL;
}
md_directive = tmp_md_d;
}
if (source_zone.empty() &&
(s->bucket->get_tenant() == s->src_tenant_name) &&
(s->bucket->get_name() == s->src_bucket_name) &&
(s->object->get_name() == s->src_object->get_name()) &&
s->src_object->get_instance().empty() &&
(attrs_mod != rgw::sal::ATTRSMOD_REPLACE)) {
need_to_check_storage_class = true;
}
return 0;
}
int RGWCopyObj_ObjStore_S3::check_storage_class(const rgw_placement_rule& src_placement)
{
if (src_placement == s->dest_placement) {
/* can only copy object into itself if replacing attrs */
s->err.message = "This copy request is illegal because it is trying to copy "
"an object to itself without changing the object's metadata, "
"storage class, website redirect location or encryption attributes.";
ldpp_dout(this, 0) << s->err.message << dendl;
return -ERR_INVALID_REQUEST;
}
return 0;
}
void RGWCopyObj_ObjStore_S3::send_partial_response(off_t ofs)
{
if (! sent_header) {
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
// Explicitly use chunked transfer encoding so that we can stream the result
// to the user without having to wait for the full length of it.
end_header(s, this, to_mime_type(s->format), CHUNKED_TRANSFER_ENCODING);
dump_start(s);
if (op_ret == 0) {
s->formatter->open_object_section_in_ns("CopyObjectResult", XMLNS_AWS_S3);
}
sent_header = true;
} else {
/* Send progress field. Note that this diverge from the original S3
* spec. We do this in order to keep connection alive.
*/
s->formatter->dump_int("Progress", (uint64_t)ofs);
}
rgw_flush_formatter(s, s->formatter);
}
void RGWCopyObj_ObjStore_S3::send_response()
{
if (!sent_header)
send_partial_response(0);
if (op_ret == 0) {
dump_time(s, "LastModified", mtime);
if (!etag.empty()) {
s->formatter->dump_format("ETag", "\"%s\"",etag.c_str());
}
s->formatter->close_section();
rgw_flush_formatter_and_reset(s, s->formatter);
}
}
void RGWGetACLs_ObjStore_S3::send_response()
{
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
dump_start(s);
rgw_flush_formatter(s, s->formatter);
dump_body(s, acls);
}
int RGWPutACLs_ObjStore_S3::get_params(optional_yield y)
{
int ret = RGWPutACLs_ObjStore::get_params(y);
if (ret >= 0) {
const int ret_auth = do_aws4_auth_completion();
if (ret_auth < 0) {
return ret_auth;
}
} else {
/* a request body is not required an S3 PutACLs request--n.b.,
* s->length is non-null iff a content length was parsed (the
* ACP or canned ACL could be in any of 3 headers, don't worry
* about that here) */
if ((ret == -ERR_LENGTH_REQUIRED) &&
!!(s->length)) {
return 0;
}
}
return ret;
}
int RGWPutACLs_ObjStore_S3::get_policy_from_state(rgw::sal::Driver* driver,
req_state *s,
stringstream& ss)
{
RGWAccessControlPolicy_S3 s3policy(s->cct);
// bucket-* canned acls do not apply to bucket
if (rgw::sal::Object::empty(s->object.get())) {
if (s->canned_acl.find("bucket") != string::npos)
s->canned_acl.clear();
}
int r = create_s3_policy(s, driver, s3policy, owner);
if (r < 0)
return r;
s3policy.to_xml(ss);
return 0;
}
void RGWPutACLs_ObjStore_S3::send_response()
{
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
dump_start(s);
}
void RGWGetLC_ObjStore_S3::execute(optional_yield y)
{
config.set_ctx(s->cct);
map<string, bufferlist>::iterator aiter = s->bucket_attrs.find(RGW_ATTR_LC);
if (aiter == s->bucket_attrs.end()) {
op_ret = -ENOENT;
return;
}
bufferlist::const_iterator iter{&aiter->second};
try {
config.decode(iter);
} catch (const buffer::error& e) {
ldpp_dout(this, 0) << __func__ << "decode life cycle config failed" << dendl;
op_ret = -EIO;
return;
}
}
void RGWGetLC_ObjStore_S3::send_response()
{
if (op_ret) {
if (op_ret == -ENOENT) {
set_req_state_err(s, ERR_NO_SUCH_LC);
} else {
set_req_state_err(s, op_ret);
}
}
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
dump_start(s);
if (op_ret < 0)
return;
encode_xml("LifecycleConfiguration", XMLNS_AWS_S3, config, s->formatter);
rgw_flush_formatter_and_reset(s, s->formatter);
}
void RGWPutLC_ObjStore_S3::send_response()
{
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
dump_start(s);
}
void RGWDeleteLC_ObjStore_S3::send_response()
{
if (op_ret == 0)
op_ret = STATUS_NO_CONTENT;
if (op_ret) {
set_req_state_err(s, op_ret);
}
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
dump_start(s);
}
void RGWGetCORS_ObjStore_S3::send_response()
{
if (op_ret) {
if (op_ret == -ENOENT)
set_req_state_err(s, ERR_NO_SUCH_CORS_CONFIGURATION);
else
set_req_state_err(s, op_ret);
}
dump_errno(s);
end_header(s, NULL, to_mime_type(s->format));
dump_start(s);
if (! op_ret) {
string cors;
RGWCORSConfiguration_S3 *s3cors =
static_cast<RGWCORSConfiguration_S3 *>(&bucket_cors);
stringstream ss;
s3cors->to_xml(ss);
cors = ss.str();
dump_body(s, cors);
}
}
int RGWPutCORS_ObjStore_S3::get_params(optional_yield y)
{
RGWCORSXMLParser_S3 parser(this, s->cct);
RGWCORSConfiguration_S3 *cors_config;
const auto max_size = s->cct->_conf->rgw_max_put_param_size;
int r = 0;
bufferlist data;
std::tie(r, data) = read_all_input(s, max_size, false);
if (r < 0) {
return r;
}
if (!parser.init()) {
return -EINVAL;
}
char* buf = data.c_str();
if (!buf || !parser.parse(buf, data.length(), 1)) {
return -ERR_MALFORMED_XML;
}
cors_config =
static_cast<RGWCORSConfiguration_S3 *>(parser.find_first(
"CORSConfiguration"));
if (!cors_config) {
return -ERR_MALFORMED_XML;
}
#define CORS_RULES_MAX_NUM 100
int max_num = s->cct->_conf->rgw_cors_rules_max_num;
if (max_num < 0) {
max_num = CORS_RULES_MAX_NUM;
}
int cors_rules_num = cors_config->get_rules().size();
if (cors_rules_num > max_num) {
ldpp_dout(this, 4) << "An cors config can have up to "
<< max_num
<< " rules, request cors rules num: "
<< cors_rules_num << dendl;
op_ret = -ERR_INVALID_CORS_RULES_ERROR;
s->err.message = "The number of CORS rules should not exceed allowed limit of "
+ std::to_string(max_num) + " rules.";
return -ERR_INVALID_REQUEST;
}
// forward bucket cors requests to meta master zone
if (!driver->is_meta_master()) {
/* only need to keep this data around if we're not meta master */
in_data.append(data);
}
if (s->cct->_conf->subsys.should_gather<ceph_subsys_rgw, 15>()) {
ldpp_dout(this, 15) << "CORSConfiguration";
cors_config->to_xml(*_dout);
*_dout << dendl;
}
cors_config->encode(cors_bl);
return 0;
}
void RGWPutCORS_ObjStore_S3::send_response()
{
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, NULL, to_mime_type(s->format));
dump_start(s);
}
void RGWDeleteCORS_ObjStore_S3::send_response()
{
int r = op_ret;
if (!r || r == -ENOENT)
r = STATUS_NO_CONTENT;
set_req_state_err(s, r);
dump_errno(s);
end_header(s, NULL);
}
void RGWOptionsCORS_ObjStore_S3::send_response()
{
string hdrs, exp_hdrs;
uint32_t max_age = CORS_MAX_AGE_INVALID;
/*EACCES means, there is no CORS registered yet for the bucket
*ENOENT means, there is no match of the Origin in the list of CORSRule
*/
if (op_ret == -ENOENT)
op_ret = -EACCES;
if (op_ret < 0) {
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, NULL);
return;
}
get_response_params(hdrs, exp_hdrs, &max_age);
dump_errno(s);
dump_access_control(s, origin, req_meth, hdrs.c_str(), exp_hdrs.c_str(),
max_age);
end_header(s, NULL);
}
void RGWPutBucketEncryption_ObjStore_S3::send_response()
{
if (op_ret) {
set_req_state_err(s, op_ret);
}
dump_errno(s);
end_header(s);
}
void RGWGetBucketEncryption_ObjStore_S3::send_response()
{
if (op_ret) {
if (op_ret == -ENOENT)
set_req_state_err(s, ERR_NO_SUCH_BUCKET_ENCRYPTION_CONFIGURATION);
else
set_req_state_err(s, op_ret);
}
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
dump_start(s);
if (!op_ret) {
encode_xml("ServerSideEncryptionConfiguration", XMLNS_AWS_S3,
bucket_encryption_conf, s->formatter);
rgw_flush_formatter_and_reset(s, s->formatter);
}
}
void RGWDeleteBucketEncryption_ObjStore_S3::send_response()
{
if (op_ret == 0) {
op_ret = STATUS_NO_CONTENT;
}
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s);
}
void RGWGetRequestPayment_ObjStore_S3::send_response()
{
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
dump_start(s);
s->formatter->open_object_section_in_ns("RequestPaymentConfiguration", XMLNS_AWS_S3);
const char *payer = requester_pays ? "Requester" : "BucketOwner";
s->formatter->dump_string("Payer", payer);
s->formatter->close_section();
rgw_flush_formatter_and_reset(s, s->formatter);
}
class RGWSetRequestPaymentParser : public RGWXMLParser
{
XMLObj *alloc_obj(const char *el) override {
return new XMLObj;
}
public:
RGWSetRequestPaymentParser() {}
~RGWSetRequestPaymentParser() override {}
int get_request_payment_payer(bool *requester_pays) {
XMLObj *config = find_first("RequestPaymentConfiguration");
if (!config)
return -EINVAL;
*requester_pays = false;
XMLObj *field = config->find_first("Payer");
if (!field)
return 0;
auto& s = field->get_data();
if (stringcasecmp(s, "Requester") == 0) {
*requester_pays = true;
} else if (stringcasecmp(s, "BucketOwner") != 0) {
return -EINVAL;
}
return 0;
}
};
int RGWSetRequestPayment_ObjStore_S3::get_params(optional_yield y)
{
const auto max_size = s->cct->_conf->rgw_max_put_param_size;
int r = 0;
std::tie(r, in_data) = read_all_input(s, max_size, false);
if (r < 0) {
return r;
}
RGWSetRequestPaymentParser parser;
if (!parser.init()) {
ldpp_dout(this, 0) << "ERROR: failed to initialize parser" << dendl;
return -EIO;
}
char* buf = in_data.c_str();
if (!parser.parse(buf, in_data.length(), 1)) {
ldpp_dout(this, 10) << "failed to parse data: " << buf << dendl;
return -EINVAL;
}
return parser.get_request_payment_payer(&requester_pays);
}
void RGWSetRequestPayment_ObjStore_S3::send_response()
{
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s);
}
int RGWInitMultipart_ObjStore_S3::get_params(optional_yield y)
{
int ret;
ret = get_encryption_defaults(s);
if (ret < 0) {
ldpp_dout(this, 5) << __func__ << "(): get_encryption_defaults() returned ret=" << ret << dendl;
return ret;
}
RGWAccessControlPolicy_S3 s3policy(s->cct);
ret = create_s3_policy(s, driver, s3policy, s->owner);
if (ret < 0)
return ret;
policy = s3policy;
return 0;
}
void RGWInitMultipart_ObjStore_S3::send_response()
{
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
for (auto &it : crypt_http_responses)
dump_header(s, it.first, it.second);
ceph::real_time abort_date;
string rule_id;
bool exist_multipart_abort = get_s3_multipart_abort_header(s, mtime, abort_date, rule_id);
if (exist_multipart_abort) {
dump_time_header(s, "x-amz-abort-date", abort_date);
dump_header_if_nonempty(s, "x-amz-abort-rule-id", rule_id);
}
end_header(s, this, to_mime_type(s->format));
if (op_ret == 0) {
dump_start(s);
s->formatter->open_object_section_in_ns("InitiateMultipartUploadResult", XMLNS_AWS_S3);
if (!s->bucket_tenant.empty())
s->formatter->dump_string("Tenant", s->bucket_tenant);
s->formatter->dump_string("Bucket", s->bucket_name);
s->formatter->dump_string("Key", s->object->get_name());
s->formatter->dump_string("UploadId", upload_id);
s->formatter->close_section();
rgw_flush_formatter_and_reset(s, s->formatter);
}
}
int RGWInitMultipart_ObjStore_S3::prepare_encryption(map<string, bufferlist>& attrs)
{
int res = 0;
res = rgw_s3_prepare_encrypt(s, attrs, nullptr, crypt_http_responses);
return res;
}
int RGWCompleteMultipart_ObjStore_S3::get_params(optional_yield y)
{
int ret = RGWCompleteMultipart_ObjStore::get_params(y);
if (ret < 0) {
return ret;
}
map_qs_metadata(s, true);
return do_aws4_auth_completion();
}
void RGWCompleteMultipart_ObjStore_S3::send_response()
{
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
dump_header_if_nonempty(s, "x-amz-version-id", version_id);
end_header(s, this, to_mime_type(s->format));
if (op_ret == 0) {
dump_start(s);
s->formatter->open_object_section_in_ns("CompleteMultipartUploadResult", XMLNS_AWS_S3);
std::string base_uri = compute_domain_uri(s);
if (!s->bucket_tenant.empty()) {
s->formatter->dump_format("Location", "%s/%s:%s/%s",
base_uri.c_str(),
s->bucket_tenant.c_str(),
s->bucket_name.c_str(),
s->object->get_name().c_str()
);
s->formatter->dump_string("Tenant", s->bucket_tenant);
} else {
s->formatter->dump_format("Location", "%s/%s/%s",
base_uri.c_str(),
s->bucket_name.c_str(),
s->object->get_name().c_str()
);
}
s->formatter->dump_string("Bucket", s->bucket_name);
s->formatter->dump_string("Key", s->object->get_name());
s->formatter->dump_string("ETag", etag);
s->formatter->close_section();
rgw_flush_formatter_and_reset(s, s->formatter);
}
}
void RGWAbortMultipart_ObjStore_S3::send_response()
{
int r = op_ret;
if (!r)
r = STATUS_NO_CONTENT;
set_req_state_err(s, r);
dump_errno(s);
end_header(s, this);
}
void RGWListMultipart_ObjStore_S3::send_response()
{
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
// Explicitly use chunked transfer encoding so that we can stream the result
// to the user without having to wait for the full length of it.
end_header(s, this, to_mime_type(s->format), CHUNKED_TRANSFER_ENCODING);
if (op_ret == 0) {
dump_start(s);
s->formatter->open_object_section_in_ns("ListPartsResult", XMLNS_AWS_S3);
map<uint32_t, std::unique_ptr<rgw::sal::MultipartPart>>::iterator iter;
map<uint32_t, std::unique_ptr<rgw::sal::MultipartPart>>::reverse_iterator test_iter;
int cur_max = 0;
iter = upload->get_parts().begin();
test_iter = upload->get_parts().rbegin();
if (test_iter != upload->get_parts().rend()) {
cur_max = test_iter->first;
}
if (!s->bucket_tenant.empty())
s->formatter->dump_string("Tenant", s->bucket_tenant);
s->formatter->dump_string("Bucket", s->bucket_name);
s->formatter->dump_string("Key", s->object->get_name());
s->formatter->dump_string("UploadId", upload_id);
s->formatter->dump_string("StorageClass", placement->get_storage_class());
s->formatter->dump_int("PartNumberMarker", marker);
s->formatter->dump_int("NextPartNumberMarker", cur_max);
s->formatter->dump_int("MaxParts", max_parts);
s->formatter->dump_string("IsTruncated", (truncated ? "true" : "false"));
ACLOwner& owner = policy.get_owner();
dump_owner(s, owner.get_id(), owner.get_display_name());
for (; iter != upload->get_parts().end(); ++iter) {
rgw::sal::MultipartPart* part = iter->second.get();
s->formatter->open_object_section("Part");
dump_time(s, "LastModified", part->get_mtime());
s->formatter->dump_unsigned("PartNumber", part->get_num());
s->formatter->dump_format("ETag", "\"%s\"", part->get_etag().c_str());
s->formatter->dump_unsigned("Size", part->get_size());
s->formatter->close_section();
}
s->formatter->close_section();
rgw_flush_formatter_and_reset(s, s->formatter);
}
}
void RGWListBucketMultiparts_ObjStore_S3::send_response()
{
if (op_ret < 0)
set_req_state_err(s, op_ret);
dump_errno(s);
// Explicitly use chunked transfer encoding so that we can stream the result
// to the user without having to wait for the full length of it.
end_header(s, this, to_mime_type(s->format), CHUNKED_TRANSFER_ENCODING);
dump_start(s);
if (op_ret < 0)
return;
s->formatter->open_object_section_in_ns("ListMultipartUploadsResult", XMLNS_AWS_S3);
if (!s->bucket_tenant.empty())
s->formatter->dump_string("Tenant", s->bucket_tenant);
s->formatter->dump_string("Bucket", s->bucket_name);
if (!prefix.empty())
s->formatter->dump_string("Prefix", prefix);
if (!marker_key.empty())
s->formatter->dump_string("KeyMarker", marker_key);
if (!marker_upload_id.empty())
s->formatter->dump_string("UploadIdMarker", marker_upload_id);
if (!next_marker_key.empty())
s->formatter->dump_string("NextKeyMarker", next_marker_key);
if (!next_marker_upload_id.empty())
s->formatter->dump_string("NextUploadIdMarker", next_marker_upload_id);
s->formatter->dump_int("MaxUploads", max_uploads);
if (!delimiter.empty())
s->formatter->dump_string("Delimiter", delimiter);
s->formatter->dump_string("IsTruncated", (is_truncated ? "true" : "false"));
if (op_ret >= 0) {
vector<std::unique_ptr<rgw::sal::MultipartUpload>>::iterator iter;
for (iter = uploads.begin(); iter != uploads.end(); ++iter) {
rgw::sal::MultipartUpload* upload = iter->get();
s->formatter->open_array_section("Upload");
if (encode_url) {
s->formatter->dump_string("Key", url_encode(upload->get_key(), false));
} else {
s->formatter->dump_string("Key", upload->get_key());
}
s->formatter->dump_string("UploadId", upload->get_upload_id());
const ACLOwner& owner = upload->get_owner();
dump_owner(s, owner.get_id(), owner.get_display_name(), "Initiator");
dump_owner(s, owner.get_id(), owner.get_display_name()); // Owner
s->formatter->dump_string("StorageClass", "STANDARD");
dump_time(s, "Initiated", upload->get_mtime());
s->formatter->close_section();
}
if (!common_prefixes.empty()) {
s->formatter->open_array_section("CommonPrefixes");
for (const auto& kv : common_prefixes) {
if (encode_url) {
s->formatter->dump_string("Prefix", url_encode(kv.first, false));
} else {
s->formatter->dump_string("Prefix", kv.first);
}
}
s->formatter->close_section();
}
}
s->formatter->close_section();
rgw_flush_formatter_and_reset(s, s->formatter);
}
int RGWDeleteMultiObj_ObjStore_S3::get_params(optional_yield y)
{
int ret = RGWDeleteMultiObj_ObjStore::get_params(y);
if (ret < 0) {
return ret;
}
const char *bypass_gov_header = s->info.env->get("HTTP_X_AMZ_BYPASS_GOVERNANCE_RETENTION");
if (bypass_gov_header) {
std::string bypass_gov_decoded = url_decode(bypass_gov_header);
bypass_governance_mode = boost::algorithm::iequals(bypass_gov_decoded, "true");
}
return do_aws4_auth_completion();
}
void RGWDeleteMultiObj_ObjStore_S3::send_status()
{
if (! status_dumped) {
if (op_ret < 0)
set_req_state_err(s, op_ret);
dump_errno(s);
status_dumped = true;
}
}
void RGWDeleteMultiObj_ObjStore_S3::begin_response()
{
if (!status_dumped) {
send_status();
}
dump_start(s);
// Explicitly use chunked transfer encoding so that we can stream the result
// to the user without having to wait for the full length of it.
end_header(s, this, to_mime_type(s->format), CHUNKED_TRANSFER_ENCODING);
s->formatter->open_object_section_in_ns("DeleteResult", XMLNS_AWS_S3);
rgw_flush_formatter(s, s->formatter);
}
void RGWDeleteMultiObj_ObjStore_S3::send_partial_response(const rgw_obj_key& key,
bool delete_marker,
const string& marker_version_id,
int ret,
boost::asio::deadline_timer *formatter_flush_cond)
{
if (!key.empty()) {
delete_multi_obj_entry ops_log_entry;
ops_log_entry.key = key.name;
ops_log_entry.version_id = key.instance;
if (ret == 0) {
ops_log_entry.error = false;
ops_log_entry.http_status = 200;
ops_log_entry.delete_marker = delete_marker;
if (delete_marker) {
ops_log_entry.marker_version_id = marker_version_id;
}
if (!quiet) {
s->formatter->open_object_section("Deleted");
s->formatter->dump_string("Key", key.name);
if (!key.instance.empty()) {
s->formatter->dump_string("VersionId", key.instance);
}
if (delete_marker) {
s->formatter->dump_bool("DeleteMarker", true);
s->formatter->dump_string("DeleteMarkerVersionId", marker_version_id);
}
s->formatter->close_section();
}
} else if (ret < 0) {
struct rgw_http_error r;
int err_no;
s->formatter->open_object_section("Error");
err_no = -ret;
rgw_get_errno_s3(&r, err_no);
ops_log_entry.error = true;
ops_log_entry.http_status = r.http_ret;
ops_log_entry.error_message = r.s3_code;
s->formatter->dump_string("Key", key.name);
s->formatter->dump_string("VersionId", key.instance);
s->formatter->dump_string("Code", r.s3_code);
s->formatter->dump_string("Message", r.s3_code);
s->formatter->close_section();
}
ops_log_entries.push_back(std::move(ops_log_entry));
if (formatter_flush_cond) {
formatter_flush_cond->cancel();
} else {
rgw_flush_formatter(s, s->formatter);
}
}
}
void RGWDeleteMultiObj_ObjStore_S3::end_response()
{
s->formatter->close_section();
rgw_flush_formatter_and_reset(s, s->formatter);
}
void RGWGetObjLayout_ObjStore_S3::send_response()
{
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this, "application/json");
JSONFormatter f;
if (op_ret < 0) {
return;
}
f.open_object_section("result");
s->object->dump_obj_layout(this, s->yield, &f);
f.close_section();
rgw_flush_formatter(s, &f);
}
int RGWConfigBucketMetaSearch_ObjStore_S3::get_params(optional_yield y)
{
auto iter = s->info.x_meta_map.find("x-amz-meta-search");
if (iter == s->info.x_meta_map.end()) {
s->err.message = "X-Rgw-Meta-Search header not provided";
ldpp_dout(this, 5) << s->err.message << dendl;
return -EINVAL;
}
list<string> expressions;
get_str_list(iter->second, ",", expressions);
for (auto& expression : expressions) {
vector<string> args;
get_str_vec(expression, ";", args);
if (args.empty()) {
s->err.message = "invalid empty expression";
ldpp_dout(this, 5) << s->err.message << dendl;
return -EINVAL;
}
if (args.size() > 2) {
s->err.message = string("invalid expression: ") + expression;
ldpp_dout(this, 5) << s->err.message << dendl;
return -EINVAL;
}
string key = boost::algorithm::to_lower_copy(rgw_trim_whitespace(args[0]));
string val;
if (args.size() > 1) {
val = boost::algorithm::to_lower_copy(rgw_trim_whitespace(args[1]));
}
if (!boost::algorithm::starts_with(key, RGW_AMZ_META_PREFIX)) {
s->err.message = string("invalid expression, key must start with '" RGW_AMZ_META_PREFIX "' : ") + expression;
ldpp_dout(this, 5) << s->err.message << dendl;
return -EINVAL;
}
key = key.substr(sizeof(RGW_AMZ_META_PREFIX) - 1);
ESEntityTypeMap::EntityType entity_type;
if (val.empty() || val == "str" || val == "string") {
entity_type = ESEntityTypeMap::ES_ENTITY_STR;
} else if (val == "int" || val == "integer") {
entity_type = ESEntityTypeMap::ES_ENTITY_INT;
} else if (val == "date" || val == "datetime") {
entity_type = ESEntityTypeMap::ES_ENTITY_DATE;
} else {
s->err.message = string("invalid entity type: ") + val;
ldpp_dout(this, 5) << s->err.message << dendl;
return -EINVAL;
}
mdsearch_config[key] = entity_type;
}
return 0;
}
void RGWConfigBucketMetaSearch_ObjStore_S3::send_response()
{
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this);
}
void RGWGetBucketMetaSearch_ObjStore_S3::send_response()
{
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, NULL, to_mime_type(s->format));
Formatter *f = s->formatter;
f->open_array_section("GetBucketMetaSearchResult");
for (auto& e : s->bucket->get_info().mdsearch_config) {
f->open_object_section("Entry");
string k = string("x-amz-meta-") + e.first;
f->dump_string("Key", k.c_str());
const char *type;
switch (e.second) {
case ESEntityTypeMap::ES_ENTITY_INT:
type = "int";
break;
case ESEntityTypeMap::ES_ENTITY_DATE:
type = "date";
break;
default:
type = "str";
}
f->dump_string("Type", type);
f->close_section();
}
f->close_section();
rgw_flush_formatter(s, f);
}
void RGWDelBucketMetaSearch_ObjStore_S3::send_response()
{
if (op_ret)
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this);
}
void RGWPutBucketObjectLock_ObjStore_S3::send_response()
{
if (op_ret) {
set_req_state_err(s, op_ret);
}
dump_errno(s);
end_header(s);
}
void RGWGetBucketObjectLock_ObjStore_S3::send_response()
{
if (op_ret) {
set_req_state_err(s, op_ret);
}
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
dump_start(s);
if (op_ret) {
return;
}
encode_xml("ObjectLockConfiguration", s->bucket->get_info().obj_lock, s->formatter);
rgw_flush_formatter_and_reset(s, s->formatter);
}
int RGWPutObjRetention_ObjStore_S3::get_params(optional_yield y)
{
const char *bypass_gov_header = s->info.env->get("HTTP_X_AMZ_BYPASS_GOVERNANCE_RETENTION");
if (bypass_gov_header) {
std::string bypass_gov_decoded = url_decode(bypass_gov_header);
bypass_governance_mode = boost::algorithm::iequals(bypass_gov_decoded, "true");
}
const auto max_size = s->cct->_conf->rgw_max_put_param_size;
std::tie(op_ret, data) = read_all_input(s, max_size, false);
return op_ret;
}
void RGWPutObjRetention_ObjStore_S3::send_response()
{
if (op_ret) {
set_req_state_err(s, op_ret);
}
dump_errno(s);
end_header(s);
}
void RGWGetObjRetention_ObjStore_S3::send_response()
{
if (op_ret) {
set_req_state_err(s, op_ret);
}
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
dump_start(s);
if (op_ret) {
return;
}
encode_xml("Retention", obj_retention, s->formatter);
rgw_flush_formatter_and_reset(s, s->formatter);
}
void RGWPutObjLegalHold_ObjStore_S3::send_response()
{
if (op_ret) {
set_req_state_err(s, op_ret);
}
dump_errno(s);
end_header(s);
}
void RGWGetObjLegalHold_ObjStore_S3::send_response()
{
if (op_ret) {
set_req_state_err(s, op_ret);
}
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
dump_start(s);
if (op_ret) {
return;
}
encode_xml("LegalHold", obj_legal_hold, s->formatter);
rgw_flush_formatter_and_reset(s, s->formatter);
}
void RGWGetBucketPolicyStatus_ObjStore_S3::send_response()
{
if (op_ret) {
set_req_state_err(s, op_ret);
}
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
dump_start(s);
s->formatter->open_object_section_in_ns("PolicyStatus", XMLNS_AWS_S3);
// https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETPolicyStatus.html
// mentions TRUE and FALSE, but boto/aws official clients seem to want lower
// case which is returned by AWS as well; so let's be bug to bug compatible
// with the API
s->formatter->dump_bool("IsPublic", isPublic);
s->formatter->close_section();
rgw_flush_formatter_and_reset(s, s->formatter);
}
void RGWPutBucketPublicAccessBlock_ObjStore_S3::send_response()
{
if (op_ret) {
set_req_state_err(s, op_ret);
}
dump_errno(s);
end_header(s);
}
void RGWGetBucketPublicAccessBlock_ObjStore_S3::send_response()
{
if (op_ret) {
set_req_state_err(s, op_ret);
}
dump_errno(s);
end_header(s, this, to_mime_type(s->format));
dump_start(s);
access_conf.dump_xml(s->formatter);
rgw_flush_formatter_and_reset(s, s->formatter);
}
RGWOp *RGWHandler_REST_Service_S3::op_get()
{
if (is_usage_op()) {
return new RGWGetUsage_ObjStore_S3;
} else {
return new RGWListBuckets_ObjStore_S3;
}
}
RGWOp *RGWHandler_REST_Service_S3::op_head()
{
return new RGWListBuckets_ObjStore_S3;
}
RGWOp *RGWHandler_REST_Bucket_S3::get_obj_op(bool get_data) const
{
// Non-website mode
if (get_data) {
int list_type = 1;
s->info.args.get_int("list-type", &list_type, 1);
switch (list_type) {
case 1:
return new RGWListBucket_ObjStore_S3;
case 2:
return new RGWListBucket_ObjStore_S3v2;
default:
ldpp_dout(s, 5) << __func__ << ": unsupported list-type " << list_type << dendl;
return new RGWListBucket_ObjStore_S3;
}
} else {
return new RGWStatBucket_ObjStore_S3;
}
}
RGWOp *RGWHandler_REST_Bucket_S3::op_get()
{
if (s->info.args.sub_resource_exists("encryption"))
return nullptr;
if (s->info.args.sub_resource_exists("logging"))
return new RGWGetBucketLogging_ObjStore_S3;
if (s->info.args.sub_resource_exists("location"))
return new RGWGetBucketLocation_ObjStore_S3;
if (s->info.args.sub_resource_exists("versioning"))
return new RGWGetBucketVersioning_ObjStore_S3;
if (s->info.args.sub_resource_exists("website")) {
if (!s->cct->_conf->rgw_enable_static_website) {
return NULL;
}
return new RGWGetBucketWebsite_ObjStore_S3;
}
if (s->info.args.exists("mdsearch")) {
return new RGWGetBucketMetaSearch_ObjStore_S3;
}
if (is_acl_op()) {
return new RGWGetACLs_ObjStore_S3;
} else if (is_cors_op()) {
return new RGWGetCORS_ObjStore_S3;
} else if (is_request_payment_op()) {
return new RGWGetRequestPayment_ObjStore_S3;
} else if (s->info.args.exists("uploads")) {
return new RGWListBucketMultiparts_ObjStore_S3;
} else if(is_lc_op()) {
return new RGWGetLC_ObjStore_S3;
} else if(is_policy_op()) {
return new RGWGetBucketPolicy;
} else if (is_tagging_op()) {
return new RGWGetBucketTags_ObjStore_S3;
} else if (is_object_lock_op()) {
return new RGWGetBucketObjectLock_ObjStore_S3;
} else if (is_notification_op()) {
return RGWHandler_REST_PSNotifs_S3::create_get_op();
} else if (is_replication_op()) {
return new RGWGetBucketReplication_ObjStore_S3;
} else if (is_policy_status_op()) {
return new RGWGetBucketPolicyStatus_ObjStore_S3;
} else if (is_block_public_access_op()) {
return new RGWGetBucketPublicAccessBlock_ObjStore_S3;
} else if (is_bucket_encryption_op()) {
return new RGWGetBucketEncryption_ObjStore_S3;
}
return get_obj_op(true);
}
RGWOp *RGWHandler_REST_Bucket_S3::op_head()
{
if (is_acl_op()) {
return new RGWGetACLs_ObjStore_S3;
} else if (s->info.args.exists("uploads")) {
return new RGWListBucketMultiparts_ObjStore_S3;
}
return get_obj_op(false);
}
RGWOp *RGWHandler_REST_Bucket_S3::op_put()
{
if (s->info.args.sub_resource_exists("logging") ||
s->info.args.sub_resource_exists("encryption"))
return nullptr;
if (s->info.args.sub_resource_exists("versioning"))
return new RGWSetBucketVersioning_ObjStore_S3;
if (s->info.args.sub_resource_exists("website")) {
if (!s->cct->_conf->rgw_enable_static_website) {
return NULL;
}
return new RGWSetBucketWebsite_ObjStore_S3;
}
if (is_tagging_op()) {
return new RGWPutBucketTags_ObjStore_S3;
} else if (is_acl_op()) {
return new RGWPutACLs_ObjStore_S3;
} else if (is_cors_op()) {
return new RGWPutCORS_ObjStore_S3;
} else if (is_request_payment_op()) {
return new RGWSetRequestPayment_ObjStore_S3;
} else if(is_lc_op()) {
return new RGWPutLC_ObjStore_S3;
} else if(is_policy_op()) {
return new RGWPutBucketPolicy;
} else if (is_object_lock_op()) {
return new RGWPutBucketObjectLock_ObjStore_S3;
} else if (is_notification_op()) {
return RGWHandler_REST_PSNotifs_S3::create_put_op();
} else if (is_replication_op()) {
RGWBucketSyncPolicyHandlerRef sync_policy_handler;
int ret = driver->get_sync_policy_handler(s, nullopt, nullopt,
&sync_policy_handler, null_yield);
if (ret < 0 || !sync_policy_handler ||
sync_policy_handler->is_legacy_config()) {
return nullptr;
}
return new RGWPutBucketReplication_ObjStore_S3;
} else if (is_block_public_access_op()) {
return new RGWPutBucketPublicAccessBlock_ObjStore_S3;
} else if (is_bucket_encryption_op()) {
return new RGWPutBucketEncryption_ObjStore_S3;
}
return new RGWCreateBucket_ObjStore_S3;
}
RGWOp *RGWHandler_REST_Bucket_S3::op_delete()
{
if (s->info.args.sub_resource_exists("logging") ||
s->info.args.sub_resource_exists("encryption"))
return nullptr;
if (is_tagging_op()) {
return new RGWDeleteBucketTags_ObjStore_S3;
} else if (is_cors_op()) {
return new RGWDeleteCORS_ObjStore_S3;
} else if(is_lc_op()) {
return new RGWDeleteLC_ObjStore_S3;
} else if(is_policy_op()) {
return new RGWDeleteBucketPolicy;
} else if (is_notification_op()) {
return RGWHandler_REST_PSNotifs_S3::create_delete_op();
} else if (is_replication_op()) {
return new RGWDeleteBucketReplication_ObjStore_S3;
} else if (is_block_public_access_op()) {
return new RGWDeleteBucketPublicAccessBlock;
} else if (is_bucket_encryption_op()) {
return new RGWDeleteBucketEncryption_ObjStore_S3;
}
if (s->info.args.sub_resource_exists("website")) {
if (!s->cct->_conf->rgw_enable_static_website) {
return NULL;
}
return new RGWDeleteBucketWebsite_ObjStore_S3;
}
if (s->info.args.exists("mdsearch")) {
return new RGWDelBucketMetaSearch_ObjStore_S3;
}
return new RGWDeleteBucket_ObjStore_S3;
}
RGWOp *RGWHandler_REST_Bucket_S3::op_post()
{
if (s->info.args.exists("delete")) {
return new RGWDeleteMultiObj_ObjStore_S3;
}
if (s->info.args.exists("mdsearch")) {
return new RGWConfigBucketMetaSearch_ObjStore_S3;
}
return new RGWPostObj_ObjStore_S3;
}
RGWOp *RGWHandler_REST_Bucket_S3::op_options()
{
return new RGWOptionsCORS_ObjStore_S3;
}
RGWOp *RGWHandler_REST_Obj_S3::get_obj_op(bool get_data)
{
RGWGetObj_ObjStore_S3 *get_obj_op = new RGWGetObj_ObjStore_S3;
get_obj_op->set_get_data(get_data);
return get_obj_op;
}
RGWOp *RGWHandler_REST_Obj_S3::op_get()
{
if (is_acl_op()) {
return new RGWGetACLs_ObjStore_S3;
} else if (s->info.args.exists("uploadId")) {
return new RGWListMultipart_ObjStore_S3;
} else if (s->info.args.exists("layout")) {
return new RGWGetObjLayout_ObjStore_S3;
} else if (is_tagging_op()) {
return new RGWGetObjTags_ObjStore_S3;
} else if (is_obj_retention_op()) {
return new RGWGetObjRetention_ObjStore_S3;
} else if (is_obj_legal_hold_op()) {
return new RGWGetObjLegalHold_ObjStore_S3;
}
return get_obj_op(true);
}
RGWOp *RGWHandler_REST_Obj_S3::op_head()
{
if (is_acl_op()) {
return new RGWGetACLs_ObjStore_S3;
} else if (s->info.args.exists("uploadId")) {
return new RGWListMultipart_ObjStore_S3;
}
return get_obj_op(false);
}
RGWOp *RGWHandler_REST_Obj_S3::op_put()
{
if (is_acl_op()) {
return new RGWPutACLs_ObjStore_S3;
} else if (is_tagging_op()) {
return new RGWPutObjTags_ObjStore_S3;
} else if (is_obj_retention_op()) {
return new RGWPutObjRetention_ObjStore_S3;
} else if (is_obj_legal_hold_op()) {
return new RGWPutObjLegalHold_ObjStore_S3;
}
if (s->init_state.src_bucket.empty())
return new RGWPutObj_ObjStore_S3;
else
return new RGWCopyObj_ObjStore_S3;
}
RGWOp *RGWHandler_REST_Obj_S3::op_delete()
{
if (is_tagging_op()) {
return new RGWDeleteObjTags_ObjStore_S3;
}
string upload_id = s->info.args.get("uploadId");
if (upload_id.empty())
return new RGWDeleteObj_ObjStore_S3;
else
return new RGWAbortMultipart_ObjStore_S3;
}
RGWOp *RGWHandler_REST_Obj_S3::op_post()
{
if (s->info.args.exists("uploadId"))
return new RGWCompleteMultipart_ObjStore_S3;
if (s->info.args.exists("uploads"))
return new RGWInitMultipart_ObjStore_S3;
if (is_select_op())
return rgw::s3select::create_s3select_op();
return new RGWPostObj_ObjStore_S3;
}
RGWOp *RGWHandler_REST_Obj_S3::op_options()
{
return new RGWOptionsCORS_ObjStore_S3;
}
int RGWHandler_REST_S3::init_from_header(rgw::sal::Driver* driver,
req_state* s,
RGWFormat default_formatter,
bool configurable_format)
{
string req;
string first;
const char *req_name = s->relative_uri.c_str();
const char *p;
if (*req_name == '?') {
p = req_name;
} else {
p = s->info.request_params.c_str();
}
s->info.args.set(p);
s->info.args.parse(s);
/* must be called after the args parsing */
int ret = allocate_formatter(s, default_formatter, configurable_format);
if (ret < 0)
return ret;
if (*req_name != '/')
return 0;
req_name++;
if (!*req_name)
return 0;
req = req_name;
int pos = req.find('/');
if (pos >= 0) {
first = req.substr(0, pos);
} else {
first = req;
}
/*
* XXX The intent of the check for empty is apparently to let the bucket
* name from DNS to be set ahead. However, we currently take the DNS
* bucket and re-insert it into URL in rgw_rest.cc:RGWREST::preprocess().
* So, this check is meaningless.
*
* Rather than dropping this, the code needs to be changed into putting
* the bucket (and its tenant) from DNS and Host: header (HTTP_HOST)
* into req_status.bucket_name directly.
*/
if (s->init_state.url_bucket.empty()) {
// Save bucket to tide us over until token is parsed.
s->init_state.url_bucket = first;
string encoded_obj_str;
if (pos >= 0) {
encoded_obj_str = req.substr(pos+1);
}
/* dang: s->bucket is never set here, since it's created with permissions.
* These calls will always create an object with no bucket. */
if (!encoded_obj_str.empty()) {
if (s->bucket) {
s->object = s->bucket->get_object(rgw_obj_key(encoded_obj_str, s->info.args.get("versionId")));
} else {
s->object = driver->get_object(rgw_obj_key(encoded_obj_str, s->info.args.get("versionId")));
}
}
} else {
if (s->bucket) {
s->object = s->bucket->get_object(rgw_obj_key(req_name, s->info.args.get("versionId")));
} else {
s->object = driver->get_object(rgw_obj_key(req_name, s->info.args.get("versionId")));
}
}
return 0;
}
int RGWHandler_REST_S3::postauth_init(optional_yield y)
{
struct req_init_state *t = &s->init_state;
int ret = rgw_parse_url_bucket(t->url_bucket, s->user->get_tenant(),
s->bucket_tenant, s->bucket_name);
if (ret) {
return ret;
}
if (s->auth.identity->get_identity_type() == TYPE_ROLE) {
s->bucket_tenant = s->auth.identity->get_role_tenant();
}
ldpp_dout(s, 10) << "s->object=" << s->object
<< " s->bucket=" << rgw_make_bucket_entry_name(s->bucket_tenant, s->bucket_name) << dendl;
ret = rgw_validate_tenant_name(s->bucket_tenant);
if (ret)
return ret;
if (!s->bucket_name.empty() && !rgw::sal::Object::empty(s->object.get())) {
ret = validate_object_name(s->object->get_name());
if (ret)
return ret;
}
if (!t->src_bucket.empty()) {
string auth_tenant;
if (s->auth.identity->get_identity_type() == TYPE_ROLE) {
auth_tenant = s->auth.identity->get_role_tenant();
} else {
auth_tenant = s->user->get_tenant();
}
ret = rgw_parse_url_bucket(t->src_bucket, auth_tenant,
s->src_tenant_name, s->src_bucket_name);
if (ret) {
return ret;
}
ret = rgw_validate_tenant_name(s->src_tenant_name);
if (ret)
return ret;
}
const char *mfa = s->info.env->get("HTTP_X_AMZ_MFA");
if (mfa) {
ret = s->user->verify_mfa(string(mfa), &s->mfa_verified, s, y);
}
return 0;
}
int RGWHandler_REST_S3::init(rgw::sal::Driver* driver, req_state *s,
rgw::io::BasicClient *cio)
{
int ret;
s->dialect = "s3";
ret = rgw_validate_tenant_name(s->bucket_tenant);
if (ret)
return ret;
if (!s->bucket_name.empty()) {
ret = validate_object_name(s->object->get_name());
if (ret)
return ret;
}
const char *cacl = s->info.env->get("HTTP_X_AMZ_ACL");
if (cacl)
s->canned_acl = cacl;
s->has_acl_header = s->info.env->exists_prefix("HTTP_X_AMZ_GRANT");
const char *copy_source = s->info.env->get("HTTP_X_AMZ_COPY_SOURCE");
if (copy_source &&
(! s->info.env->get("HTTP_X_AMZ_COPY_SOURCE_RANGE")) &&
(! s->info.args.exists("uploadId"))) {
rgw_obj_key key;
ret = RGWCopyObj::parse_copy_location(copy_source,
s->init_state.src_bucket,
key,
s);
if (!ret) {
ldpp_dout(s, 0) << "failed to parse copy location" << dendl;
return -EINVAL; // XXX why not -ERR_INVALID_BUCKET_NAME or -ERR_BAD_URL?
}
s->src_object = driver->get_object(key);
}
const char *sc = s->info.env->get("HTTP_X_AMZ_STORAGE_CLASS");
if (sc) {
s->info.storage_class = sc;
}
return RGWHandler_REST::init(driver, s, cio);
}
int RGWHandler_REST_S3::authorize(const DoutPrefixProvider *dpp, optional_yield y)
{
if (s->info.args.exists("Action") && s->info.args.get("Action") == "AssumeRoleWithWebIdentity") {
return RGW_Auth_STS::authorize(dpp, driver, auth_registry, s, y);
}
return RGW_Auth_S3::authorize(dpp, driver, auth_registry, s, y);
}
enum class AwsVersion {
UNKNOWN,
V2,
V4
};
enum class AwsRoute {
UNKNOWN,
QUERY_STRING,
HEADERS
};
static inline std::pair<AwsVersion, AwsRoute>
discover_aws_flavour(const req_info& info)
{
using rgw::auth::s3::AWS4_HMAC_SHA256_STR;
AwsVersion version = AwsVersion::UNKNOWN;
AwsRoute route = AwsRoute::UNKNOWN;
const char* http_auth = info.env->get("HTTP_AUTHORIZATION");
if (http_auth && http_auth[0]) {
/* Authorization in Header */
route = AwsRoute::HEADERS;
if (!strncmp(http_auth, AWS4_HMAC_SHA256_STR,
strlen(AWS4_HMAC_SHA256_STR))) {
/* AWS v4 */
version = AwsVersion::V4;
} else if (!strncmp(http_auth, "AWS ", 4)) {
/* AWS v2 */
version = AwsVersion::V2;
}
} else {
route = AwsRoute::QUERY_STRING;
if (info.args.get("x-amz-algorithm") == AWS4_HMAC_SHA256_STR) {
/* AWS v4 */
version = AwsVersion::V4;
} else if (!info.args.get("AWSAccessKeyId").empty()) {
/* AWS v2 */
version = AwsVersion::V2;
}
}
return std::make_pair(version, route);
}
/*
* verify that a signed request comes from the keyholder
* by checking the signature against our locally-computed version
*
* it tries AWS v4 before AWS v2
*/
int RGW_Auth_S3::authorize(const DoutPrefixProvider *dpp,
rgw::sal::Driver* const driver,
const rgw::auth::StrategyRegistry& auth_registry,
req_state* const s, optional_yield y)
{
/* neither keystone and rados enabled; warn and exit! */
if (!driver->ctx()->_conf->rgw_s3_auth_use_rados &&
!driver->ctx()->_conf->rgw_s3_auth_use_keystone &&
!driver->ctx()->_conf->rgw_s3_auth_use_ldap) {
ldpp_dout(dpp, 0) << "WARNING: no authorization backend enabled! Users will never authenticate." << dendl;
return -EPERM;
}
const auto ret = rgw::auth::Strategy::apply(dpp, auth_registry.get_s3_main(), s, y);
if (ret == 0) {
/* Populate the owner info. */
s->owner.set_id(s->user->get_id());
s->owner.set_name(s->user->get_display_name());
}
return ret;
}
int RGWHandler_Auth_S3::init(rgw::sal::Driver* driver, req_state *state,
rgw::io::BasicClient *cio)
{
int ret = RGWHandler_REST_S3::init_from_header(driver, state, RGWFormat::JSON, true);
if (ret < 0)
return ret;
return RGWHandler_REST::init(driver, state, cio);
}
namespace {
// utility classes and functions for handling parameters with the following format:
// Attributes.entry.{N}.{key|value}={VALUE}
// N - any unsigned number
// VALUE - url encoded string
// and Attribute is holding key and value
// ctor and set are done according to the "type" argument
// if type is not "key" or "value" its a no-op
class Attribute {
std::string key;
std::string value;
public:
Attribute(const std::string& type, const std::string& key_or_value) {
set(type, key_or_value);
}
void set(const std::string& type, const std::string& key_or_value) {
if (type == "key") {
key = key_or_value;
} else if (type == "value") {
value = key_or_value;
}
}
const std::string& get_key() const { return key; }
const std::string& get_value() const { return value; }
};
using AttributeMap = std::map<unsigned, Attribute>;
// aggregate the attributes into a map
// the key and value are associated by the index (N)
// no assumptions are made on the order in which these parameters are added
void update_attribute_map(const std::string& input, AttributeMap& map) {
const boost::char_separator<char> sep(".");
const boost::tokenizer tokens(input, sep);
auto token = tokens.begin();
if (*token != "Attributes") {
return;
}
++token;
if (*token != "entry") {
return;
}
++token;
unsigned idx;
try {
idx = std::stoul(*token);
} catch (const std::invalid_argument&) {
return;
}
++token;
std::string key_or_value = "";
// get the rest of the string regardless of dots
// this is to allow dots in the value
while (token != tokens.end()) {
key_or_value.append(*token+".");
++token;
}
// remove last separator
key_or_value.pop_back();
auto pos = key_or_value.find("=");
if (pos != std::string::npos) {
const auto key_or_value_lhs = key_or_value.substr(0, pos);
const auto key_or_value_rhs = url_decode(key_or_value.substr(pos + 1, key_or_value.size() - 1));
const auto map_it = map.find(idx);
if (map_it == map.end()) {
// new entry
map.emplace(std::make_pair(idx, Attribute(key_or_value_lhs, key_or_value_rhs)));
} else {
// existing entry
map_it->second.set(key_or_value_lhs, key_or_value_rhs);
}
}
}
}
void parse_post_action(const std::string& post_body, req_state* s)
{
if (post_body.size() > 0) {
ldpp_dout(s, 10) << "Content of POST: " << post_body << dendl;
if (post_body.find("Action") != string::npos) {
const boost::char_separator<char> sep("&");
const boost::tokenizer<boost::char_separator<char>> tokens(post_body, sep);
AttributeMap map;
for (const auto& t : tokens) {
const auto pos = t.find("=");
if (pos != string::npos) {
const auto key = t.substr(0, pos);
if (boost::starts_with(key, "Attributes.")) {
update_attribute_map(t, map);
} else {
s->info.args.append(t.substr(0, pos),
url_decode(t.substr(pos+1, t.size() -1)));
}
}
}
// update the regular args with the content of the attribute map
for (const auto& attr : map) {
s->info.args.append(attr.second.get_key(), attr.second.get_value());
}
}
}
const auto payload_hash = rgw::auth::s3::calc_v4_payload_hash(post_body);
s->info.args.append("PayloadHash", payload_hash);
}
RGWHandler_REST* RGWRESTMgr_S3::get_handler(rgw::sal::Driver* driver,
req_state* const s,
const rgw::auth::StrategyRegistry& auth_registry,
const std::string& frontend_prefix)
{
bool is_s3website = enable_s3website && (s->prot_flags & RGW_REST_WEBSITE);
int ret =
RGWHandler_REST_S3::init_from_header(driver, s,
is_s3website ? RGWFormat::HTML :
RGWFormat::XML, true);
if (ret < 0) {
return nullptr;
}
if (is_s3website) {
if (s->init_state.url_bucket.empty()) {
return new RGWHandler_REST_Service_S3Website(auth_registry);
}
if (rgw::sal::Object::empty(s->object.get())) {
return new RGWHandler_REST_Bucket_S3Website(auth_registry);
}
return new RGWHandler_REST_Obj_S3Website(auth_registry);
}
if (s->init_state.url_bucket.empty()) {
// no bucket
if (s->op == OP_POST) {
// POST will be one of: IAM, STS or topic service
const auto max_size = s->cct->_conf->rgw_max_put_param_size;
int ret;
bufferlist data;
std::tie(ret, data) = rgw_rest_read_all_input(s, max_size, false);
if (ret < 0) {
return nullptr;
}
parse_post_action(data.to_str(), s);
if (enable_sts && RGWHandler_REST_STS::action_exists(s)) {
return new RGWHandler_REST_STS(auth_registry);
}
if (enable_iam && RGWHandler_REST_IAM::action_exists(s)) {
return new RGWHandler_REST_IAM(auth_registry, data);
}
if (enable_pubsub && RGWHandler_REST_PSTopic_AWS::action_exists(s)) {
return new RGWHandler_REST_PSTopic_AWS(auth_registry);
}
return nullptr;
}
// non-POST S3 service without a bucket
return new RGWHandler_REST_Service_S3(auth_registry);
}
if (!rgw::sal::Object::empty(s->object.get())) {
// has object
return new RGWHandler_REST_Obj_S3(auth_registry);
}
if (s->info.args.exist_obj_excl_sub_resource()) {
return nullptr;
}
// has bucket
return new RGWHandler_REST_Bucket_S3(auth_registry, enable_pubsub);
}
bool RGWHandler_REST_S3Website::web_dir() const {
std::string subdir_name;
if (!rgw::sal::Object::empty(s->object.get())) {
subdir_name = url_decode(s->object->get_name());
}
if (subdir_name.empty()) {
return false;
} else if (subdir_name.back() == '/' && subdir_name.size() > 1) {
subdir_name.pop_back();
}
std::unique_ptr<rgw::sal::Object> obj = s->bucket->get_object(rgw_obj_key(subdir_name));
obj->set_atomic();
obj->set_prefetch_data();
RGWObjState* state = nullptr;
if (obj->get_obj_state(s, &state, s->yield) < 0) {
return false;
}
if (! state->exists) {
return false;
}
return state->exists;
}
int RGWHandler_REST_S3Website::init(rgw::sal::Driver* driver, req_state *s,
rgw::io::BasicClient* cio)
{
// save the original object name before retarget() replaces it with the
// result of get_effective_key(). the error_handler() needs the original
// object name for redirect handling
if (!rgw::sal::Object::empty(s->object.get())) {
original_object_name = s->object->get_name();
} else {
original_object_name = "";
}
return RGWHandler_REST_S3::init(driver, s, cio);
}
int RGWHandler_REST_S3Website::retarget(RGWOp* op, RGWOp** new_op, optional_yield y) {
*new_op = op;
ldpp_dout(s, 10) << __func__ << " Starting retarget" << dendl;
if (!(s->prot_flags & RGW_REST_WEBSITE))
return 0;
if (rgw::sal::Bucket::empty(s->bucket.get())) {
// TODO-FUTURE: if the bucket does not exist, maybe expose it here?
return -ERR_NO_SUCH_BUCKET;
}
if (!s->bucket->get_info().has_website) {
// TODO-FUTURE: if the bucket has no WebsiteConfig, expose it here
return -ERR_NO_SUCH_WEBSITE_CONFIGURATION;
}
rgw_obj_key new_obj;
string key_name;
if (!rgw::sal::Object::empty(s->object.get())) {
key_name = s->object->get_name();
}
bool get_res = s->bucket->get_info().website_conf.get_effective_key(key_name, &new_obj.name, web_dir());
if (!get_res) {
s->err.message = "The IndexDocument Suffix is not configurated or not well formed!";
ldpp_dout(s, 5) << s->err.message << dendl;
return -EINVAL;
}
ldpp_dout(s, 10) << "retarget get_effective_key " << s->object << " -> "
<< new_obj << dendl;
RGWBWRoutingRule rrule;
bool should_redirect =
s->bucket->get_info().website_conf.should_redirect(new_obj.name, 0, &rrule);
if (should_redirect) {
const string& hostname = s->info.env->get("HTTP_HOST", "");
const string& protocol =
(s->info.env->get("SERVER_PORT_SECURE") ? "https" : "http");
int redirect_code = 0;
rrule.apply_rule(protocol, hostname, key_name, &s->redirect,
&redirect_code);
// APply a custom HTTP response code
if (redirect_code > 0)
s->err.http_ret = redirect_code; // Apply a custom HTTP response code
ldpp_dout(s, 10) << "retarget redirect code=" << redirect_code
<< " proto+host:" << protocol << "://" << hostname
<< " -> " << s->redirect << dendl;
return -ERR_WEBSITE_REDIRECT;
}
/*
* FIXME: if s->object != new_obj, drop op and create a new op to handle
* operation. Or remove this comment if it's not applicable anymore
* dang: This could be problematic, since we're not actually replacing op, but
* we are replacing s->object. Something might have a pointer to it.
*/
s->object = s->bucket->get_object(new_obj);
return 0;
}
RGWOp* RGWHandler_REST_S3Website::op_get()
{
return get_obj_op(true);
}
RGWOp* RGWHandler_REST_S3Website::op_head()
{
return get_obj_op(false);
}
int RGWHandler_REST_S3Website::serve_errordoc(const DoutPrefixProvider *dpp, int http_ret, const string& errordoc_key, optional_yield y) {
int ret = 0;
s->formatter->reset(); /* Try to throw it all away */
std::shared_ptr<RGWGetObj_ObjStore_S3Website> getop( static_cast<RGWGetObj_ObjStore_S3Website*>(op_get()));
if (getop.get() == NULL) {
return -1; // Trigger double error handler
}
getop->init(driver, s, this);
getop->range_str = NULL;
getop->if_mod = NULL;
getop->if_unmod = NULL;
getop->if_match = NULL;
getop->if_nomatch = NULL;
/* 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
* are set up. Note, it won't have bucket. */
s->object = driver->get_object(errordoc_key);
ret = init_permissions(getop.get(), y);
if (ret < 0) {
ldpp_dout(s, 20) << "serve_errordoc failed, init_permissions ret=" << ret << dendl;
return -1; // Trigger double error handler
}
ret = read_permissions(getop.get(), y);
if (ret < 0) {
ldpp_dout(s, 20) << "serve_errordoc failed, read_permissions ret=" << ret << dendl;
return -1; // Trigger double error handler
}
if (http_ret) {
getop->set_custom_http_response(http_ret);
}
ret = getop->init_processing(y);
if (ret < 0) {
ldpp_dout(s, 20) << "serve_errordoc failed, init_processing ret=" << ret << dendl;
return -1; // Trigger double error handler
}
ret = getop->verify_op_mask();
if (ret < 0) {
ldpp_dout(s, 20) << "serve_errordoc failed, verify_op_mask ret=" << ret << dendl;
return -1; // Trigger double error handler
}
ret = getop->verify_permission(y);
if (ret < 0) {
ldpp_dout(s, 20) << "serve_errordoc failed, verify_permission ret=" << ret << dendl;
return -1; // Trigger double error handler
}
ret = getop->verify_params();
if (ret < 0) {
ldpp_dout(s, 20) << "serve_errordoc failed, verify_params ret=" << ret << dendl;
return -1; // Trigger double error handler
}
// No going back now
getop->pre_exec();
/*
* FIXME Missing headers:
* With a working errordoc, the s3 error fields are rendered as HTTP headers,
* x-amz-error-code: NoSuchKey
* x-amz-error-message: The specified key does not exist.
* x-amz-error-detail-Key: foo
*/
getop->execute(y);
getop->complete();
return 0;
}
int RGWHandler_REST_S3Website::error_handler(int err_no,
string* error_content,
optional_yield y) {
int new_err_no = -1;
rgw_http_errors::const_iterator r = rgw_http_s3_errors.find(err_no > 0 ? err_no : -err_no);
int http_error_code = -1;
if (r != rgw_http_s3_errors.end()) {
http_error_code = r->second.first;
}
ldpp_dout(s, 10) << "RGWHandler_REST_S3Website::error_handler err_no=" << err_no << " http_ret=" << http_error_code << dendl;
RGWBWRoutingRule rrule;
bool have_bucket = !rgw::sal::Bucket::empty(s->bucket.get());
bool should_redirect = false;
if (have_bucket) {
should_redirect =
s->bucket->get_info().website_conf.should_redirect(original_object_name,
http_error_code, &rrule);
}
if (should_redirect) {
const string& hostname = s->info.env->get("HTTP_HOST", "");
const string& protocol =
(s->info.env->get("SERVER_PORT_SECURE") ? "https" : "http");
int redirect_code = 0;
rrule.apply_rule(protocol, hostname, original_object_name,
&s->redirect, &redirect_code);
// Apply a custom HTTP response code
if (redirect_code > 0)
s->err.http_ret = redirect_code; // Apply a custom HTTP response code
ldpp_dout(s, 10) << "error handler redirect code=" << redirect_code
<< " proto+host:" << protocol << "://" << hostname
<< " -> " << s->redirect << dendl;
return -ERR_WEBSITE_REDIRECT;
} else if (err_no == -ERR_WEBSITE_REDIRECT) {
// Do nothing here, this redirect will be handled in abort_early's ERR_WEBSITE_REDIRECT block
// Do NOT fire the ErrorDoc handler
} else if (have_bucket && !s->bucket->get_info().website_conf.error_doc.empty()) {
/* This serves an entire page!
On success, it will return zero, and no further content should be sent to the socket
On failure, we need the double-error handler
*/
new_err_no = RGWHandler_REST_S3Website::serve_errordoc(s, http_error_code, s->bucket->get_info().website_conf.error_doc, y);
if (new_err_no != -1) {
err_no = new_err_no;
}
} else {
ldpp_dout(s, 20) << "No special error handling today!" << dendl;
}
return err_no;
}
RGWOp* RGWHandler_REST_Obj_S3Website::get_obj_op(bool get_data)
{
/** If we are in website mode, then it is explicitly impossible to run GET or
* HEAD on the actual directory. We must convert the request to run on the
* suffix object instead!
*/
RGWGetObj_ObjStore_S3Website* op = new RGWGetObj_ObjStore_S3Website;
op->set_get_data(get_data);
return op;
}
RGWOp* RGWHandler_REST_Bucket_S3Website::get_obj_op(bool get_data)
{
/** If we are in website mode, then it is explicitly impossible to run GET or
* HEAD on the actual directory. We must convert the request to run on the
* suffix object instead!
*/
RGWGetObj_ObjStore_S3Website* op = new RGWGetObj_ObjStore_S3Website;
op->set_get_data(get_data);
return op;
}
RGWOp* RGWHandler_REST_Service_S3Website::get_obj_op(bool get_data)
{
/** If we are in website mode, then it is explicitly impossible to run GET or
* HEAD on the actual directory. We must convert the request to run on the
* suffix object instead!
*/
RGWGetObj_ObjStore_S3Website* op = new RGWGetObj_ObjStore_S3Website;
op->set_get_data(get_data);
return op;
}
namespace rgw::auth::s3 {
static rgw::auth::Completer::cmplptr_t
null_completer_factory(const boost::optional<std::string>& secret_key)
{
return nullptr;
}
AWSEngine::VersionAbstractor::auth_data_t
AWSGeneralAbstractor::get_auth_data(const req_state* const s) const
{
AwsVersion version;
AwsRoute route;
std::tie(version, route) = discover_aws_flavour(s->info);
if (version == AwsVersion::V2) {
return get_auth_data_v2(s);
} else if (version == AwsVersion::V4) {
return get_auth_data_v4(s, route == AwsRoute::QUERY_STRING);
} else {
/* FIXME(rzarzynski): handle anon user. */
throw -EINVAL;
}
}
boost::optional<std::string>
AWSGeneralAbstractor::get_v4_canonical_headers(
const req_info& info,
const std::string_view& signedheaders,
const bool using_qs) const
{
return rgw::auth::s3::get_v4_canonical_headers(info, signedheaders,
using_qs, false);
}
AWSSignerV4::prepare_result_t
AWSSignerV4::prepare(const DoutPrefixProvider *dpp,
const std::string& access_key_id,
const string& region,
const string& service,
const req_info& info,
const bufferlist *opt_content,
bool s3_op)
{
std::string signed_hdrs;
ceph::real_time timestamp = ceph::real_clock::now();
map<string, string> extra_headers;
std::string date = ceph::to_iso_8601_no_separators(timestamp, ceph::iso_8601_format::YMDhms);
std::string credential_scope = gen_v4_scope(timestamp, region, service);
extra_headers["x-amz-date"] = date;
string content_hash;
if (opt_content) {
content_hash = rgw::auth::s3::calc_v4_payload_hash(opt_content->to_str());
extra_headers["x-amz-content-sha256"] = content_hash;
}
/* craft canonical headers */
std::string canonical_headers = \
gen_v4_canonical_headers(info, extra_headers, &signed_hdrs);
using sanitize = rgw::crypt_sanitize::log_content;
ldpp_dout(dpp, 10) << "canonical headers format = "
<< sanitize{canonical_headers} << dendl;
bool is_non_s3_op = !s3_op;
const char* exp_payload_hash = nullptr;
string payload_hash;
if (is_non_s3_op) {
//For non s3 ops, we need to calculate the payload hash
payload_hash = info.args.get("PayloadHash");
exp_payload_hash = payload_hash.c_str();
} else {
/* Get the expected hash. */
if (content_hash.empty()) {
exp_payload_hash = rgw::auth::s3::get_v4_exp_payload_hash(info);
} else {
exp_payload_hash = content_hash.c_str();
}
}
/* Craft canonical URI. Using std::move later so let it be non-const. */
auto canonical_uri = rgw::auth::s3::gen_v4_canonical_uri(info);
/* Craft canonical query string. std::moving later so non-const here. */
auto canonical_qs = rgw::auth::s3::gen_v4_canonical_qs(info, is_non_s3_op);
auto cct = dpp->get_cct();
/* Craft canonical request. */
auto canonical_req_hash = \
rgw::auth::s3::get_v4_canon_req_hash(cct,
info.method,
std::move(canonical_uri),
std::move(canonical_qs),
std::move(canonical_headers),
signed_hdrs,
exp_payload_hash,
dpp);
auto string_to_sign = \
rgw::auth::s3::get_v4_string_to_sign(cct,
AWS4_HMAC_SHA256_STR,
date,
credential_scope,
std::move(canonical_req_hash),
dpp);
const auto sig_factory = gen_v4_signature;
/* Requests authenticated with the Query Parameters are treated as unsigned.
* From "Authenticating Requests: Using Query Parameters (AWS Signature
* Version 4)":
*
* You don't include a payload hash in the Canonical Request, because
* when you create a presigned URL, you don't know the payload content
* because the URL is used to upload an arbitrary payload. Instead, you
* use a constant string UNSIGNED-PAYLOAD.
*
* This means we have absolutely no business in spawning completer. Both
* aws4_auth_needs_complete and aws4_auth_streaming_mode are set to false
* by default. We don't need to change that. */
return {
access_key_id,
date,
credential_scope,
std::move(signed_hdrs),
std::move(string_to_sign),
std::move(extra_headers),
sig_factory,
};
}
AWSSignerV4::signature_headers_t
gen_v4_signature(const DoutPrefixProvider *dpp,
const std::string_view& secret_key,
const AWSSignerV4::prepare_result_t& sig_info)
{
auto signature = rgw::auth::s3::get_v4_signature(sig_info.scope,
dpp->get_cct(),
secret_key,
sig_info.string_to_sign,
dpp);
AWSSignerV4::signature_headers_t result;
for (auto& entry : sig_info.extra_headers) {
result[entry.first] = entry.second;
}
auto& payload_hash = result["x-amz-content-sha256"];
if (payload_hash.empty()) {
payload_hash = AWS4_UNSIGNED_PAYLOAD_HASH;
}
string auth_header = string("AWS4-HMAC-SHA256 Credential=").append(sig_info.access_key_id) + "/";
auth_header.append(sig_info.scope + ",SignedHeaders=")
.append(sig_info.signed_headers + ",Signature=")
.append(signature);
result["Authorization"] = auth_header;
return result;
}
AWSEngine::VersionAbstractor::auth_data_t
AWSGeneralAbstractor::get_auth_data_v4(const req_state* const s,
const bool using_qs) const
{
std::string_view access_key_id;
std::string_view signed_hdrs;
std::string_view date;
std::string_view credential_scope;
std::string_view client_signature;
std::string_view session_token;
int ret = rgw::auth::s3::parse_v4_credentials(s->info,
access_key_id,
credential_scope,
signed_hdrs,
client_signature,
date,
session_token,
using_qs,
s);
if (ret < 0) {
throw ret;
}
/* craft canonical headers */
boost::optional<std::string> canonical_headers = \
get_v4_canonical_headers(s->info, signed_hdrs, using_qs);
if (canonical_headers) {
using sanitize = rgw::crypt_sanitize::log_content;
ldpp_dout(s, 10) << "canonical headers format = "
<< sanitize{*canonical_headers} << dendl;
} else {
throw -EPERM;
}
bool is_non_s3_op = rgw::auth::s3::is_non_s3_op(s->op_type);
const char* exp_payload_hash = nullptr;
string payload_hash;
if (is_non_s3_op) {
//For non s3 ops, we need to calculate the payload hash
payload_hash = s->info.args.get("PayloadHash");
exp_payload_hash = payload_hash.c_str();
} else {
/* Get the expected hash. */
exp_payload_hash = rgw::auth::s3::get_v4_exp_payload_hash(s->info);
}
/* Craft canonical URI. Using std::move later so let it be non-const. */
auto canonical_uri = rgw::auth::s3::get_v4_canonical_uri(s->info);
/* Craft canonical query string. std::moving later so non-const here. */
auto canonical_qs = rgw::auth::s3::get_v4_canonical_qs(s->info, using_qs);
/* Craft canonical request. */
auto canonical_req_hash = \
rgw::auth::s3::get_v4_canon_req_hash(s->cct,
s->info.method,
std::move(canonical_uri),
std::move(canonical_qs),
std::move(*canonical_headers),
signed_hdrs,
exp_payload_hash,
s);
auto string_to_sign = \
rgw::auth::s3::get_v4_string_to_sign(s->cct,
AWS4_HMAC_SHA256_STR,
date,
credential_scope,
std::move(canonical_req_hash),
s);
const auto sig_factory = std::bind(rgw::auth::s3::get_v4_signature,
credential_scope,
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3,
s);
/* Requests authenticated with the Query Parameters are treated as unsigned.
* From "Authenticating Requests: Using Query Parameters (AWS Signature
* Version 4)":
*
* You don't include a payload hash in the Canonical Request, because
* when you create a presigned URL, you don't know the payload content
* because the URL is used to upload an arbitrary payload. Instead, you
* use a constant string UNSIGNED-PAYLOAD.
*
* This means we have absolutely no business in spawning completer. Both
* aws4_auth_needs_complete and aws4_auth_streaming_mode are set to false
* by default. We don't need to change that. */
if (is_v4_payload_unsigned(exp_payload_hash) || is_v4_payload_empty(s) || is_non_s3_op) {
return {
access_key_id,
client_signature,
session_token,
std::move(string_to_sign),
sig_factory,
null_completer_factory
};
} else {
/* We're going to handle a signed payload. Be aware that even empty HTTP
* body (no payload) requires verification:
*
* The x-amz-content-sha256 header is required for all AWS Signature
* Version 4 requests. It provides a hash of the request payload. If
* there is no payload, you must provide the hash of an empty string. */
if (!is_v4_payload_streamed(exp_payload_hash)) {
ldpp_dout(s, 10) << "delaying v4 auth" << dendl;
/* payload in a single chunk */
switch (s->op_type)
{
case RGW_OP_CREATE_BUCKET:
case RGW_OP_PUT_OBJ:
case RGW_OP_PUT_ACLS:
case RGW_OP_PUT_CORS:
case RGW_OP_PUT_BUCKET_ENCRYPTION:
case RGW_OP_GET_BUCKET_ENCRYPTION:
case RGW_OP_DELETE_BUCKET_ENCRYPTION:
case RGW_OP_INIT_MULTIPART: // in case that Init Multipart uses CHUNK encoding
case RGW_OP_COMPLETE_MULTIPART:
case RGW_OP_SET_BUCKET_VERSIONING:
case RGW_OP_DELETE_MULTI_OBJ:
case RGW_OP_ADMIN_SET_METADATA:
case RGW_OP_SYNC_DATALOG_NOTIFY:
case RGW_OP_SYNC_DATALOG_NOTIFY2:
case RGW_OP_SYNC_MDLOG_NOTIFY:
case RGW_OP_PERIOD_POST:
case RGW_OP_SET_BUCKET_WEBSITE:
case RGW_OP_PUT_BUCKET_POLICY:
case RGW_OP_PUT_OBJ_TAGGING:
case RGW_OP_PUT_BUCKET_TAGGING:
case RGW_OP_PUT_BUCKET_REPLICATION:
case RGW_OP_PUT_LC:
case RGW_OP_SET_REQUEST_PAYMENT:
case RGW_OP_PUBSUB_NOTIF_CREATE:
case RGW_OP_PUBSUB_NOTIF_DELETE:
case RGW_OP_PUBSUB_NOTIF_LIST:
case RGW_OP_PUT_BUCKET_OBJ_LOCK:
case RGW_OP_PUT_OBJ_RETENTION:
case RGW_OP_PUT_OBJ_LEGAL_HOLD:
case RGW_STS_GET_SESSION_TOKEN:
case RGW_STS_ASSUME_ROLE:
case RGW_OP_PUT_BUCKET_PUBLIC_ACCESS_BLOCK:
case RGW_OP_GET_BUCKET_PUBLIC_ACCESS_BLOCK:
case RGW_OP_DELETE_BUCKET_PUBLIC_ACCESS_BLOCK:
case RGW_OP_GET_OBJ://s3select its post-method(payload contain the query) , the request is get-object
break;
default:
ldpp_dout(s, 10) << "ERROR: AWS4 completion for operation: " << s->op_type << ", NOT IMPLEMENTED" << dendl;
throw -ERR_NOT_IMPLEMENTED;
}
const auto cmpl_factory = std::bind(AWSv4ComplSingle::create,
s,
std::placeholders::_1);
return {
access_key_id,
client_signature,
session_token,
std::move(string_to_sign),
sig_factory,
cmpl_factory
};
} else {
/* IMHO "streamed" doesn't fit too good here. I would prefer to call
* it "chunked" but let's be coherent with Amazon's terminology. */
ldpp_dout(s, 10) << "body content detected in multiple chunks" << dendl;
/* payload in multiple chunks */
switch(s->op_type)
{
case RGW_OP_PUT_OBJ:
break;
default:
ldpp_dout(s, 10) << "ERROR: AWS4 completion for this operation NOT IMPLEMENTED (streaming mode)" << dendl;
throw -ERR_NOT_IMPLEMENTED;
}
ldpp_dout(s, 10) << "aws4 seed signature ok... delaying v4 auth" << dendl;
/* In the case of streamed payload client sets the x-amz-content-sha256
* to "STREAMING-AWS4-HMAC-SHA256-PAYLOAD" but uses "UNSIGNED-PAYLOAD"
* when constructing the Canonical Request. */
/* In the case of single-chunk upload client set the header's value is
* coherent with the one used for Canonical Request crafting. */
/* In the case of query string-based authentication there should be no
* x-amz-content-sha256 header and the value "UNSIGNED-PAYLOAD" is used
* for CanonReq. */
const auto cmpl_factory = std::bind(AWSv4ComplMulti::create,
s,
date,
credential_scope,
client_signature,
std::placeholders::_1);
return {
access_key_id,
client_signature,
session_token,
std::move(string_to_sign),
sig_factory,
cmpl_factory
};
}
}
}
boost::optional<std::string>
AWSGeneralBoto2Abstractor::get_v4_canonical_headers(
const req_info& info,
const std::string_view& signedheaders,
const bool using_qs) const
{
return rgw::auth::s3::get_v4_canonical_headers(info, signedheaders,
using_qs, true);
}
AWSEngine::VersionAbstractor::auth_data_t
AWSGeneralAbstractor::get_auth_data_v2(const req_state* const s) const
{
std::string_view access_key_id;
std::string_view signature;
std::string_view session_token;
bool qsr = false;
const char* http_auth = s->info.env->get("HTTP_AUTHORIZATION");
if (! http_auth || http_auth[0] == '\0') {
/* Credentials are provided in query string. We also need to verify
* the "Expires" parameter now. */
access_key_id = s->info.args.get("AWSAccessKeyId");
signature = s->info.args.get("Signature");
qsr = true;
std::string_view expires = s->info.args.get("Expires");
if (expires.empty()) {
throw -EPERM;
}
/* It looks we have the guarantee that expires is a null-terminated,
* and thus string_view::data() can be safely used. */
const time_t exp = atoll(expires.data());
time_t now;
time(&now);
if (now >= exp) {
throw -EPERM;
}
if (s->info.args.exists("x-amz-security-token")) {
session_token = s->info.args.get("x-amz-security-token");
if (session_token.size() == 0) {
throw -EPERM;
}
}
} else {
/* The "Authorization" HTTP header is being used. */
const std::string_view auth_str(http_auth + strlen("AWS "));
const size_t pos = auth_str.rfind(':');
if (pos != std::string_view::npos) {
access_key_id = auth_str.substr(0, pos);
signature = auth_str.substr(pos + 1);
}
auto token = s->info.env->get_optional("HTTP_X_AMZ_SECURITY_TOKEN");
if (token) {
session_token = *token;
if (session_token.size() == 0) {
throw -EPERM;
}
}
}
/* Let's canonize the HTTP headers that are covered by the AWS auth v2. */
std::string string_to_sign;
utime_t header_time;
if (! rgw_create_s3_canonical_header(s, s->info, &header_time, string_to_sign,
qsr)) {
ldpp_dout(s, 10) << "failed to create the canonized auth header\n"
<< rgw::crypt_sanitize::auth{s,string_to_sign} << dendl;
throw -EPERM;
}
ldpp_dout(s, 10) << "string_to_sign:\n"
<< rgw::crypt_sanitize::auth{s,string_to_sign} << dendl;
if (!qsr && !is_time_skew_ok(header_time)) {
throw -ERR_REQUEST_TIME_SKEWED;
}
return {
std::move(access_key_id),
std::move(signature),
std::move(session_token),
std::move(string_to_sign),
rgw::auth::s3::get_v2_signature,
null_completer_factory
};
}
AWSEngine::VersionAbstractor::auth_data_t
AWSBrowserUploadAbstractor::get_auth_data_v2(const req_state* const s) const
{
return {
s->auth.s3_postobj_creds.access_key,
s->auth.s3_postobj_creds.signature,
s->auth.s3_postobj_creds.x_amz_security_token,
s->auth.s3_postobj_creds.encoded_policy.to_str(),
rgw::auth::s3::get_v2_signature,
null_completer_factory
};
}
AWSEngine::VersionAbstractor::auth_data_t
AWSBrowserUploadAbstractor::get_auth_data_v4(const req_state* const s) const
{
const std::string_view credential = s->auth.s3_postobj_creds.x_amz_credential;
/* grab access key id */
const size_t pos = credential.find("/");
const std::string_view access_key_id = credential.substr(0, pos);
ldpp_dout(s, 10) << "access key id = " << access_key_id << dendl;
/* grab credential scope */
const std::string_view credential_scope = credential.substr(pos + 1);
ldpp_dout(s, 10) << "credential scope = " << credential_scope << dendl;
const auto sig_factory = std::bind(rgw::auth::s3::get_v4_signature,
credential_scope,
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3,
s);
return {
access_key_id,
s->auth.s3_postobj_creds.signature,
s->auth.s3_postobj_creds.x_amz_security_token,
s->auth.s3_postobj_creds.encoded_policy.to_str(),
sig_factory,
null_completer_factory
};
}
AWSEngine::VersionAbstractor::auth_data_t
AWSBrowserUploadAbstractor::get_auth_data(const req_state* const s) const
{
if (s->auth.s3_postobj_creds.x_amz_algorithm == AWS4_HMAC_SHA256_STR) {
ldpp_dout(s, 0) << "Signature verification algorithm AWS v4"
<< " (AWS4-HMAC-SHA256)" << dendl;
return get_auth_data_v4(s);
} else {
ldpp_dout(s, 0) << "Signature verification algorithm AWS v2" << dendl;
return get_auth_data_v2(s);
}
}
AWSEngine::result_t
AWSEngine::authenticate(const DoutPrefixProvider* dpp, const req_state* const s, optional_yield y) const
{
/* Small reminder: an ver_abstractor is allowed to throw! */
const auto auth_data = ver_abstractor.get_auth_data(s);
if (auth_data.access_key_id.empty() || auth_data.client_signature.empty()) {
return result_t::deny(-EINVAL);
} else {
return authenticate(dpp,
auth_data.access_key_id,
auth_data.client_signature,
auth_data.session_token,
auth_data.string_to_sign,
auth_data.signature_factory,
auth_data.completer_factory,
s, y);
}
}
} // namespace rgw::auth::s3
rgw::LDAPHelper* rgw::auth::s3::LDAPEngine::ldh = nullptr;
std::mutex rgw::auth::s3::LDAPEngine::mtx;
void rgw::auth::s3::LDAPEngine::init(CephContext* const cct)
{
if (! cct->_conf->rgw_s3_auth_use_ldap ||
cct->_conf->rgw_ldap_uri.empty()) {
return;
}
if (! ldh) {
std::lock_guard<std::mutex> lck(mtx);
if (! ldh) {
const string& ldap_uri = cct->_conf->rgw_ldap_uri;
const string& ldap_binddn = cct->_conf->rgw_ldap_binddn;
const string& ldap_searchdn = cct->_conf->rgw_ldap_searchdn;
const string& ldap_searchfilter = cct->_conf->rgw_ldap_searchfilter;
const string& ldap_dnattr = cct->_conf->rgw_ldap_dnattr;
std::string ldap_bindpw = parse_rgw_ldap_bindpw(cct);
ldh = new rgw::LDAPHelper(ldap_uri, ldap_binddn, ldap_bindpw,
ldap_searchdn, ldap_searchfilter, ldap_dnattr);
ldh->init();
ldh->bind();
}
}
}
bool rgw::auth::s3::LDAPEngine::valid() {
std::lock_guard<std::mutex> lck(mtx);
return (!!ldh);
}
rgw::auth::RemoteApplier::acl_strategy_t
rgw::auth::s3::LDAPEngine::get_acl_strategy() const
{
//This is based on the assumption that the default acl strategy in
// get_perms_from_aclspec, will take care. Extra acl spec is not required.
return nullptr;
}
rgw::auth::RemoteApplier::AuthInfo
rgw::auth::s3::LDAPEngine::get_creds_info(const rgw::RGWToken& token) const noexcept
{
/* The short form of "using" can't be used here -- we're aliasing a class'
* member. */
using acct_privilege_t = \
rgw::auth::RemoteApplier::AuthInfo::acct_privilege_t;
return rgw::auth::RemoteApplier::AuthInfo {
rgw_user(token.id),
token.id,
RGW_PERM_FULL_CONTROL,
acct_privilege_t::IS_PLAIN_ACCT,
rgw::auth::RemoteApplier::AuthInfo::NO_ACCESS_KEY,
rgw::auth::RemoteApplier::AuthInfo::NO_SUBUSER,
TYPE_LDAP
};
}
rgw::auth::Engine::result_t
rgw::auth::s3::LDAPEngine::authenticate(
const DoutPrefixProvider* dpp,
const std::string_view& access_key_id,
const std::string_view& signature,
const std::string_view& session_token,
const string_to_sign_t& string_to_sign,
const signature_factory_t&,
const completer_factory_t& completer_factory,
const req_state* const s,
optional_yield y) const
{
/* boost filters and/or string_ref may throw on invalid input */
rgw::RGWToken base64_token;
try {
base64_token = rgw::from_base64(access_key_id);
} catch (...) {
base64_token = std::string("");
}
if (! base64_token.valid()) {
return result_t::deny();
}
//TODO: Uncomment, when we have a migration plan in place.
//Check if a user of type other than 'ldap' is already present, if yes, then
//return error.
/*RGWUserInfo user_info;
user_info.user_id = base64_token.id;
if (rgw_get_user_info_by_uid(driver, user_info.user_id, user_info) >= 0) {
if (user_info.type != TYPE_LDAP) {
ldpp_dout(dpp, 10) << "ERROR: User id of type: " << user_info.type << " is already present" << dendl;
return nullptr;
}
}*/
if (ldh->auth(base64_token.id, base64_token.key) != 0) {
return result_t::deny(-ERR_INVALID_ACCESS_KEY);
}
auto apl = apl_factory->create_apl_remote(cct, s, get_acl_strategy(),
get_creds_info(base64_token));
return result_t::grant(std::move(apl), completer_factory(boost::none));
} /* rgw::auth::s3::LDAPEngine::authenticate */
void rgw::auth::s3::LDAPEngine::shutdown() {
if (ldh) {
delete ldh;
ldh = nullptr;
}
}
/* LocalEngine */
rgw::auth::Engine::result_t
rgw::auth::s3::LocalEngine::authenticate(
const DoutPrefixProvider* dpp,
const std::string_view& _access_key_id,
const std::string_view& signature,
const std::string_view& session_token,
const string_to_sign_t& string_to_sign,
const signature_factory_t& signature_factory,
const completer_factory_t& completer_factory,
const req_state* const s,
optional_yield y) const
{
/* get the user info */
std::unique_ptr<rgw::sal::User> user;
const std::string access_key_id(_access_key_id);
/* TODO(rzarzynski): we need to have string-view taking variant. */
if (driver->get_user_by_access_key(dpp, access_key_id, y, &user) < 0) {
ldpp_dout(dpp, 5) << "error reading user info, uid=" << access_key_id
<< " can't authenticate" << dendl;
return result_t::deny(-ERR_INVALID_ACCESS_KEY);
}
//TODO: Uncomment, when we have a migration plan in place.
/*else {
if (s->user->type != TYPE_RGW) {
ldpp_dout(dpp, 10) << "ERROR: User id of type: " << s->user->type
<< " is present" << dendl;
throw -EPERM;
}
}*/
const auto iter = user->get_info().access_keys.find(access_key_id);
if (iter == std::end(user->get_info().access_keys)) {
ldpp_dout(dpp, 0) << "ERROR: access key not encoded in user info" << dendl;
return result_t::deny(-EPERM);
}
const RGWAccessKey& k = iter->second;
const VersionAbstractor::server_signature_t server_signature = \
signature_factory(cct, k.key, string_to_sign);
auto compare = signature.compare(server_signature);
ldpp_dout(dpp, 15) << "string_to_sign="
<< rgw::crypt_sanitize::log_content{string_to_sign}
<< dendl;
ldpp_dout(dpp, 15) << "server signature=" << server_signature << dendl;
ldpp_dout(dpp, 15) << "client signature=" << signature << dendl;
ldpp_dout(dpp, 15) << "compare=" << compare << dendl;
if (compare != 0) {
return result_t::deny(-ERR_SIGNATURE_NO_MATCH);
}
auto apl = apl_factory->create_apl_local(cct, s, user->get_info(),
k.subuser, std::nullopt, access_key_id);
return result_t::grant(std::move(apl), completer_factory(k.key));
}
rgw::auth::RemoteApplier::AuthInfo
rgw::auth::s3::STSEngine::get_creds_info(const STS::SessionToken& token) const noexcept
{
using acct_privilege_t = \
rgw::auth::RemoteApplier::AuthInfo::acct_privilege_t;
return rgw::auth::RemoteApplier::AuthInfo {
token.user,
token.acct_name,
token.perm_mask,
(token.is_admin) ? acct_privilege_t::IS_ADMIN_ACCT: acct_privilege_t::IS_PLAIN_ACCT,
token.access_key_id,
rgw::auth::RemoteApplier::AuthInfo::NO_SUBUSER,
token.acct_type
};
}
int
rgw::auth::s3::STSEngine::get_session_token(const DoutPrefixProvider* dpp, const std::string_view& session_token,
STS::SessionToken& token) const
{
string decodedSessionToken;
try {
decodedSessionToken = rgw::from_base64(session_token);
} catch (...) {
ldpp_dout(dpp, 0) << "ERROR: Invalid session token, not base64 encoded." << dendl;
return -EINVAL;
}
auto* cryptohandler = cct->get_crypto_handler(CEPH_CRYPTO_AES);
if (! cryptohandler) {
return -EINVAL;
}
string secret_s = cct->_conf->rgw_sts_key;
buffer::ptr secret(secret_s.c_str(), secret_s.length());
int ret = 0;
if (ret = cryptohandler->validate_secret(secret); ret < 0) {
ldpp_dout(dpp, 0) << "ERROR: Invalid secret key" << dendl;
return -EINVAL;
}
string error;
std::unique_ptr<CryptoKeyHandler> keyhandler(cryptohandler->get_key_handler(secret, error));
if (! keyhandler) {
return -EINVAL;
}
error.clear();
string decrypted_str;
buffer::list en_input, dec_output;
en_input = buffer::list::static_from_string(decodedSessionToken);
ret = keyhandler->decrypt(en_input, dec_output, &error);
if (ret < 0) {
ldpp_dout(dpp, 0) << "ERROR: Decryption failed: " << error << dendl;
return -EPERM;
} else {
try {
dec_output.append('\0');
auto iter = dec_output.cbegin();
decode(token, iter);
} catch (const buffer::error& e) {
ldpp_dout(dpp, 0) << "ERROR: decode SessionToken failed: " << error << dendl;
return -EINVAL;
}
}
return 0;
}
rgw::auth::Engine::result_t
rgw::auth::s3::STSEngine::authenticate(
const DoutPrefixProvider* dpp,
const std::string_view& _access_key_id,
const std::string_view& signature,
const std::string_view& session_token,
const string_to_sign_t& string_to_sign,
const signature_factory_t& signature_factory,
const completer_factory_t& completer_factory,
const req_state* const s,
optional_yield y) const
{
if (! s->info.args.exists("x-amz-security-token") &&
! s->info.env->exists("HTTP_X_AMZ_SECURITY_TOKEN") &&
s->auth.s3_postobj_creds.x_amz_security_token.empty()) {
return result_t::deny();
}
STS::SessionToken token;
if (int ret = get_session_token(dpp, session_token, token); ret < 0) {
return result_t::reject(ret);
}
//Authentication
//Check if access key is not the same passed in by client
if (token.access_key_id != _access_key_id) {
ldpp_dout(dpp, 0) << "Invalid access key" << dendl;
return result_t::reject(-EPERM);
}
//Check if the token has expired
if (! token.expiration.empty()) {
std::string expiration = token.expiration;
if (! expiration.empty()) {
boost::optional<real_clock::time_point> exp = ceph::from_iso_8601(expiration, false);
if (exp) {
real_clock::time_point now = real_clock::now();
if (now >= *exp) {
ldpp_dout(dpp, 0) << "ERROR: Token expired" << dendl;
return result_t::reject(-EPERM);
}
} else {
ldpp_dout(dpp, 0) << "ERROR: Invalid expiration: " << expiration << dendl;
return result_t::reject(-EPERM);
}
}
}
//Check for signature mismatch
const VersionAbstractor::server_signature_t server_signature = \
signature_factory(cct, token.secret_access_key, string_to_sign);
auto compare = signature.compare(server_signature);
ldpp_dout(dpp, 15) << "string_to_sign="
<< rgw::crypt_sanitize::log_content{string_to_sign}
<< dendl;
ldpp_dout(dpp, 15) << "server signature=" << server_signature << dendl;
ldpp_dout(dpp, 15) << "client signature=" << signature << dendl;
ldpp_dout(dpp, 15) << "compare=" << compare << dendl;
if (compare != 0) {
return result_t::reject(-ERR_SIGNATURE_NO_MATCH);
}
// Get all the authorization info
std::unique_ptr<rgw::sal::User> user;
rgw_user user_id;
string role_id;
rgw::auth::RoleApplier::Role r;
rgw::auth::RoleApplier::TokenAttrs t_attrs;
if (! token.roleId.empty()) {
std::unique_ptr<rgw::sal::RGWRole> role = driver->get_role(token.roleId);
if (role->get_by_id(dpp, y) < 0) {
return result_t::deny(-EPERM);
}
r.id = token.roleId;
r.name = role->get_name();
r.tenant = role->get_tenant();
vector<string> role_policy_names = role->get_role_policy_names();
for (auto& policy_name : role_policy_names) {
string perm_policy;
if (int ret = role->get_role_policy(dpp, policy_name, perm_policy); ret == 0) {
r.role_policies.push_back(std::move(perm_policy));
}
}
}
user = driver->get_user(token.user);
if (! token.user.empty() && token.acct_type != TYPE_ROLE) {
// get user info
int ret = user->load_user(dpp, y);
if (ret < 0) {
ldpp_dout(dpp, 5) << "ERROR: failed reading user info: uid=" << token.user << dendl;
return result_t::reject(-EPERM);
}
}
if (token.acct_type == TYPE_KEYSTONE || token.acct_type == TYPE_LDAP) {
auto apl = remote_apl_factory->create_apl_remote(cct, s, get_acl_strategy(),
get_creds_info(token));
return result_t::grant(std::move(apl), completer_factory(token.secret_access_key));
} else if (token.acct_type == TYPE_ROLE) {
t_attrs.user_id = std::move(token.user); // This is mostly needed to assign the owner of a bucket during its creation
t_attrs.token_policy = std::move(token.policy);
t_attrs.role_session_name = std::move(token.role_session);
t_attrs.token_claims = std::move(token.token_claims);
t_attrs.token_issued_at = std::move(token.issued_at);
t_attrs.principal_tags = std::move(token.principal_tags);
auto apl = role_apl_factory->create_apl_role(cct, s, r, t_attrs);
return result_t::grant(std::move(apl), completer_factory(token.secret_access_key));
} else { // This is for all local users of type TYPE_RGW or TYPE_NONE
string subuser;
auto apl = local_apl_factory->create_apl_local(cct, s, user->get_info(), subuser, token.perm_mask, std::string(_access_key_id));
return result_t::grant(std::move(apl), completer_factory(token.secret_access_key));
}
}
bool rgw::auth::s3::S3AnonymousEngine::is_applicable(
const req_state* s
) const noexcept {
if (s->op == OP_OPTIONS) {
return true;
}
AwsVersion version;
AwsRoute route;
std::tie(version, route) = discover_aws_flavour(s->info);
return route == AwsRoute::QUERY_STRING && version == AwsVersion::UNKNOWN;
}
| 199,123 | 29.943901 | 175 |
cc
|
null |
ceph-main/src/rgw/rgw_rest_s3.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#pragma once
#define TIME_BUF_SIZE 128
#include <mutex>
#include <string_view>
#include <boost/container/static_vector.hpp>
#include <boost/crc.hpp>
#include "common/sstring.hh"
#include "rgw_op.h"
#include "rgw_rest.h"
#include "rgw_http_errors.h"
#include "rgw_acl_s3.h"
#include "rgw_policy_s3.h"
#include "rgw_lc_s3.h"
#include "rgw_keystone.h"
#include "rgw_rest_conn.h"
#include "rgw_ldap.h"
#include "rgw_token.h"
#include "include/ceph_assert.h"
#include "rgw_auth.h"
#include "rgw_auth_filters.h"
#include "rgw_sts.h"
struct rgw_http_error {
int http_ret;
const char *s3_code;
};
void rgw_get_errno_s3(struct rgw_http_error *e, int err_no);
class RGWGetObj_ObjStore_S3 : public RGWGetObj_ObjStore
{
protected:
// Serving a custom error page from an object is really a 200 response with
// just the status line altered.
int custom_http_ret = 0;
std::map<std::string, std::string> crypt_http_responses;
int override_range_hdr(const rgw::auth::StrategyRegistry& auth_registry, optional_yield y);
public:
RGWGetObj_ObjStore_S3() {}
~RGWGetObj_ObjStore_S3() override {}
int verify_requester(const rgw::auth::StrategyRegistry& auth_registry, optional_yield y) override;
int get_params(optional_yield y) override;
int send_response_data_error(optional_yield y) override;
int send_response_data(bufferlist& bl, off_t ofs, off_t len) override;
void set_custom_http_response(int http_ret) { custom_http_ret = http_ret; }
int get_decrypt_filter(std::unique_ptr<RGWGetObj_Filter>* filter,
RGWGetObj_Filter* cb,
bufferlist* manifest_bl) override;
};
class RGWGetObjTags_ObjStore_S3 : public RGWGetObjTags_ObjStore
{
public:
RGWGetObjTags_ObjStore_S3() {}
~RGWGetObjTags_ObjStore_S3() {}
void send_response_data(bufferlist &bl) override;
};
class RGWPutObjTags_ObjStore_S3 : public RGWPutObjTags_ObjStore
{
public:
RGWPutObjTags_ObjStore_S3() {}
~RGWPutObjTags_ObjStore_S3() {}
int get_params(optional_yield y) override;
void send_response() override;
};
class RGWDeleteObjTags_ObjStore_S3 : public RGWDeleteObjTags
{
public:
~RGWDeleteObjTags_ObjStore_S3() override {}
void send_response() override;
};
class RGWGetBucketTags_ObjStore_S3 : public RGWGetBucketTags_ObjStore
{
bufferlist tags_bl;
public:
void send_response_data(bufferlist &bl) override;
};
class RGWPutBucketTags_ObjStore_S3 : public RGWPutBucketTags_ObjStore
{
public:
int get_params(const DoutPrefixProvider *dpp, optional_yield y) override;
void send_response() override;
};
class RGWDeleteBucketTags_ObjStore_S3 : public RGWDeleteBucketTags
{
public:
void send_response() override;
};
class RGWGetBucketReplication_ObjStore_S3 : public RGWGetBucketReplication_ObjStore
{
public:
void send_response_data() override;
};
class RGWPutBucketReplication_ObjStore_S3 : public RGWPutBucketReplication_ObjStore
{
public:
int get_params(optional_yield y) override;
void send_response() override;
};
class RGWDeleteBucketReplication_ObjStore_S3 : public RGWDeleteBucketReplication_ObjStore
{
protected:
void update_sync_policy(rgw_sync_policy_info *policy) override;
public:
void send_response() override;
};
class RGWListBuckets_ObjStore_S3 : public RGWListBuckets_ObjStore {
public:
RGWListBuckets_ObjStore_S3() {}
~RGWListBuckets_ObjStore_S3() override {}
int get_params(optional_yield y) override {
limit = -1; /* no limit */
return 0;
}
void send_response_begin(bool has_buckets) override;
void send_response_data(rgw::sal::BucketList& buckets) override;
void send_response_end() override;
};
class RGWGetUsage_ObjStore_S3 : public RGWGetUsage_ObjStore {
public:
RGWGetUsage_ObjStore_S3() {}
~RGWGetUsage_ObjStore_S3() override {}
int get_params(optional_yield y) override ;
void send_response() override;
};
class RGWListBucket_ObjStore_S3 : public RGWListBucket_ObjStore {
protected:
bool objs_container;
bool encode_key {false};
int get_common_params();
void send_common_response();
void send_common_versioned_response();
public:
RGWListBucket_ObjStore_S3() : objs_container(false) {
default_max = 1000;
}
~RGWListBucket_ObjStore_S3() override {}
int get_params(optional_yield y) override;
void send_response() override;
void send_versioned_response();
};
class RGWListBucket_ObjStore_S3v2 : public RGWListBucket_ObjStore_S3 {
bool fetchOwner;
bool start_after_exist;
bool continuation_token_exist;
std::string startAfter;
std::string continuation_token;
public:
RGWListBucket_ObjStore_S3v2() : fetchOwner(false) {
}
~RGWListBucket_ObjStore_S3v2() override {}
int get_params(optional_yield y) override;
void send_response() override;
void send_versioned_response();
};
class RGWGetBucketLogging_ObjStore_S3 : public RGWGetBucketLogging {
public:
RGWGetBucketLogging_ObjStore_S3() {}
~RGWGetBucketLogging_ObjStore_S3() override {}
void send_response() override;
};
class RGWGetBucketLocation_ObjStore_S3 : public RGWGetBucketLocation {
public:
RGWGetBucketLocation_ObjStore_S3() {}
~RGWGetBucketLocation_ObjStore_S3() override {}
void send_response() override;
};
class RGWGetBucketVersioning_ObjStore_S3 : public RGWGetBucketVersioning {
public:
RGWGetBucketVersioning_ObjStore_S3() {}
~RGWGetBucketVersioning_ObjStore_S3() override {}
void send_response() override;
};
class RGWSetBucketVersioning_ObjStore_S3 : public RGWSetBucketVersioning {
public:
RGWSetBucketVersioning_ObjStore_S3() {}
~RGWSetBucketVersioning_ObjStore_S3() override {}
int get_params(optional_yield y) override;
void send_response() override;
};
class RGWGetBucketWebsite_ObjStore_S3 : public RGWGetBucketWebsite {
public:
RGWGetBucketWebsite_ObjStore_S3() {}
~RGWGetBucketWebsite_ObjStore_S3() override {}
void send_response() override;
};
class RGWSetBucketWebsite_ObjStore_S3 : public RGWSetBucketWebsite {
public:
RGWSetBucketWebsite_ObjStore_S3() {}
~RGWSetBucketWebsite_ObjStore_S3() override {}
int get_params(optional_yield y) override;
void send_response() override;
};
class RGWDeleteBucketWebsite_ObjStore_S3 : public RGWDeleteBucketWebsite {
public:
RGWDeleteBucketWebsite_ObjStore_S3() {}
~RGWDeleteBucketWebsite_ObjStore_S3() override {}
void send_response() override;
};
class RGWStatBucket_ObjStore_S3 : public RGWStatBucket_ObjStore {
public:
RGWStatBucket_ObjStore_S3() {}
~RGWStatBucket_ObjStore_S3() override {}
void send_response() override;
};
class RGWCreateBucket_ObjStore_S3 : public RGWCreateBucket_ObjStore {
public:
RGWCreateBucket_ObjStore_S3() {}
~RGWCreateBucket_ObjStore_S3() override {}
int get_params(optional_yield y) override;
void send_response() override;
};
class RGWDeleteBucket_ObjStore_S3 : public RGWDeleteBucket_ObjStore {
public:
RGWDeleteBucket_ObjStore_S3() {}
~RGWDeleteBucket_ObjStore_S3() override {}
void send_response() override;
};
class RGWPutObj_ObjStore_S3 : public RGWPutObj_ObjStore {
private:
std::map<std::string, std::string> crypt_http_responses;
public:
RGWPutObj_ObjStore_S3() {}
~RGWPutObj_ObjStore_S3() override {}
int get_params(optional_yield y) override;
int get_data(bufferlist& bl) override;
void send_response() override;
int get_encrypt_filter(std::unique_ptr<rgw::sal::DataProcessor> *filter,
rgw::sal::DataProcessor *cb) override;
int get_decrypt_filter(std::unique_ptr<RGWGetObj_Filter>* filter,
RGWGetObj_Filter* cb,
std::map<std::string, bufferlist>& attrs,
bufferlist* manifest_bl) override;
};
class RGWPostObj_ObjStore_S3 : public RGWPostObj_ObjStore {
parts_collection_t parts;
std::string filename;
std::string content_type;
RGWPolicyEnv env;
RGWPolicy post_policy;
std::map<std::string, std::string> crypt_http_responses;
const rgw::auth::StrategyRegistry* auth_registry_ptr = nullptr;
int get_policy(optional_yield y);
int get_tags();
void rebuild_key(rgw::sal::Object* obj);
std::string get_current_filename() const override;
std::string get_current_content_type() const override;
public:
RGWPostObj_ObjStore_S3() {}
~RGWPostObj_ObjStore_S3() override {}
int verify_requester(const rgw::auth::StrategyRegistry& auth_registry, optional_yield y) override {
auth_registry_ptr = &auth_registry;
return RGWPostObj_ObjStore::verify_requester(auth_registry, y);
}
int get_params(optional_yield y) override;
int complete_get_params();
void send_response() override;
int get_data(ceph::bufferlist& bl, bool& again) override;
int get_encrypt_filter(std::unique_ptr<rgw::sal::DataProcessor> *filter,
rgw::sal::DataProcessor *cb) override;
};
class RGWDeleteObj_ObjStore_S3 : public RGWDeleteObj_ObjStore {
public:
RGWDeleteObj_ObjStore_S3() {}
~RGWDeleteObj_ObjStore_S3() override {}
int get_params(optional_yield y) override;
void send_response() override;
};
class RGWCopyObj_ObjStore_S3 : public RGWCopyObj_ObjStore {
bool sent_header;
public:
RGWCopyObj_ObjStore_S3() : sent_header(false) {}
~RGWCopyObj_ObjStore_S3() override {}
int init_dest_policy() override;
int get_params(optional_yield y) override;
int check_storage_class(const rgw_placement_rule& src_placement) override;
void send_partial_response(off_t ofs) override;
void send_response() override;
};
class RGWGetACLs_ObjStore_S3 : public RGWGetACLs_ObjStore {
public:
RGWGetACLs_ObjStore_S3() {}
~RGWGetACLs_ObjStore_S3() override {}
void send_response() override;
};
class RGWPutACLs_ObjStore_S3 : public RGWPutACLs_ObjStore {
public:
RGWPutACLs_ObjStore_S3() {}
~RGWPutACLs_ObjStore_S3() override {}
int get_policy_from_state(rgw::sal::Driver* driver, req_state *s, std::stringstream& ss) override;
void send_response() override;
int get_params(optional_yield y) override;
};
class RGWGetLC_ObjStore_S3 : public RGWGetLC_ObjStore {
protected:
RGWLifecycleConfiguration_S3 config;
public:
RGWGetLC_ObjStore_S3() {}
~RGWGetLC_ObjStore_S3() override {}
void execute(optional_yield y) override;
void send_response() override;
};
class RGWPutLC_ObjStore_S3 : public RGWPutLC_ObjStore {
public:
RGWPutLC_ObjStore_S3() {}
~RGWPutLC_ObjStore_S3() override {}
void send_response() override;
};
class RGWDeleteLC_ObjStore_S3 : public RGWDeleteLC_ObjStore {
public:
RGWDeleteLC_ObjStore_S3() {}
~RGWDeleteLC_ObjStore_S3() override {}
void send_response() override;
};
class RGWGetCORS_ObjStore_S3 : public RGWGetCORS_ObjStore {
public:
RGWGetCORS_ObjStore_S3() {}
~RGWGetCORS_ObjStore_S3() override {}
void send_response() override;
};
class RGWPutCORS_ObjStore_S3 : public RGWPutCORS_ObjStore {
public:
RGWPutCORS_ObjStore_S3() {}
~RGWPutCORS_ObjStore_S3() override {}
int get_params(optional_yield y) override;
void send_response() override;
};
class RGWDeleteCORS_ObjStore_S3 : public RGWDeleteCORS_ObjStore {
public:
RGWDeleteCORS_ObjStore_S3() {}
~RGWDeleteCORS_ObjStore_S3() override {}
void send_response() override;
};
class RGWOptionsCORS_ObjStore_S3 : public RGWOptionsCORS_ObjStore {
public:
RGWOptionsCORS_ObjStore_S3() {}
~RGWOptionsCORS_ObjStore_S3() override {}
void send_response() override;
};
class RGWGetBucketEncryption_ObjStore_S3 : public RGWGetBucketEncryption_ObjStore {
public:
RGWGetBucketEncryption_ObjStore_S3() {}
~RGWGetBucketEncryption_ObjStore_S3() override {}
void send_response() override;
};
class RGWPutBucketEncryption_ObjStore_S3 : public RGWPutBucketEncryption_ObjStore {
public:
RGWPutBucketEncryption_ObjStore_S3() {}
~RGWPutBucketEncryption_ObjStore_S3() override {}
void send_response() override;
};
class RGWDeleteBucketEncryption_ObjStore_S3 : public RGWDeleteBucketEncryption_ObjStore {
public:
RGWDeleteBucketEncryption_ObjStore_S3() {}
~RGWDeleteBucketEncryption_ObjStore_S3() override {}
void send_response() override;
};
class RGWGetRequestPayment_ObjStore_S3 : public RGWGetRequestPayment {
public:
RGWGetRequestPayment_ObjStore_S3() {}
~RGWGetRequestPayment_ObjStore_S3() override {}
void send_response() override;
};
class RGWSetRequestPayment_ObjStore_S3 : public RGWSetRequestPayment {
public:
RGWSetRequestPayment_ObjStore_S3() {}
~RGWSetRequestPayment_ObjStore_S3() override {}
int get_params(optional_yield y) override;
void send_response() override;
};
class RGWInitMultipart_ObjStore_S3 : public RGWInitMultipart_ObjStore {
private:
std::map<std::string, std::string> crypt_http_responses;
public:
RGWInitMultipart_ObjStore_S3() {}
~RGWInitMultipart_ObjStore_S3() override {}
int get_params(optional_yield y) override;
void send_response() override;
int prepare_encryption(std::map<std::string, bufferlist>& attrs) override;
};
class RGWCompleteMultipart_ObjStore_S3 : public RGWCompleteMultipart_ObjStore {
public:
RGWCompleteMultipart_ObjStore_S3() {}
~RGWCompleteMultipart_ObjStore_S3() override {}
int get_params(optional_yield y) override;
void send_response() override;
};
class RGWAbortMultipart_ObjStore_S3 : public RGWAbortMultipart_ObjStore {
public:
RGWAbortMultipart_ObjStore_S3() {}
~RGWAbortMultipart_ObjStore_S3() override {}
void send_response() override;
};
class RGWListMultipart_ObjStore_S3 : public RGWListMultipart_ObjStore {
public:
RGWListMultipart_ObjStore_S3() {}
~RGWListMultipart_ObjStore_S3() override {}
void send_response() override;
};
class RGWListBucketMultiparts_ObjStore_S3 : public RGWListBucketMultiparts_ObjStore {
public:
RGWListBucketMultiparts_ObjStore_S3() {
default_max = 1000;
}
~RGWListBucketMultiparts_ObjStore_S3() override {}
void send_response() override;
};
class RGWDeleteMultiObj_ObjStore_S3 : public RGWDeleteMultiObj_ObjStore {
public:
RGWDeleteMultiObj_ObjStore_S3() {}
~RGWDeleteMultiObj_ObjStore_S3() override {}
int get_params(optional_yield y) override;
void send_status() override;
void begin_response() override;
void send_partial_response(const rgw_obj_key& key, bool delete_marker,
const std::string& marker_version_id, int ret,
boost::asio::deadline_timer *formatter_flush_cond) override;
void end_response() override;
};
class RGWPutBucketObjectLock_ObjStore_S3 : public RGWPutBucketObjectLock_ObjStore {
public:
RGWPutBucketObjectLock_ObjStore_S3() {}
~RGWPutBucketObjectLock_ObjStore_S3() override {}
void send_response() override;
};
class RGWGetBucketObjectLock_ObjStore_S3 : public RGWGetBucketObjectLock_ObjStore {
public:
RGWGetBucketObjectLock_ObjStore_S3() {}
~RGWGetBucketObjectLock_ObjStore_S3() {}
void send_response() override;
};
class RGWPutObjRetention_ObjStore_S3 : public RGWPutObjRetention_ObjStore {
public:
RGWPutObjRetention_ObjStore_S3() {}
~RGWPutObjRetention_ObjStore_S3() {}
int get_params(optional_yield y) override;
void send_response() override;
};
class RGWGetObjRetention_ObjStore_S3 : public RGWGetObjRetention_ObjStore {
public:
RGWGetObjRetention_ObjStore_S3() {}
~RGWGetObjRetention_ObjStore_S3() {}
void send_response() override;
};
class RGWPutObjLegalHold_ObjStore_S3 : public RGWPutObjLegalHold_ObjStore {
public:
RGWPutObjLegalHold_ObjStore_S3() {}
~RGWPutObjLegalHold_ObjStore_S3() {}
void send_response() override;
};
class RGWGetObjLegalHold_ObjStore_S3 : public RGWGetObjLegalHold_ObjStore {
public:
RGWGetObjLegalHold_ObjStore_S3() {}
~RGWGetObjLegalHold_ObjStore_S3() {}
void send_response() override;
};
class RGWGetObjLayout_ObjStore_S3 : public RGWGetObjLayout {
public:
RGWGetObjLayout_ObjStore_S3() {}
~RGWGetObjLayout_ObjStore_S3() {}
void send_response() override;
};
class RGWConfigBucketMetaSearch_ObjStore_S3 : public RGWConfigBucketMetaSearch {
public:
RGWConfigBucketMetaSearch_ObjStore_S3() {}
~RGWConfigBucketMetaSearch_ObjStore_S3() {}
int get_params(optional_yield y) override;
void send_response() override;
};
class RGWGetBucketMetaSearch_ObjStore_S3 : public RGWGetBucketMetaSearch {
public:
RGWGetBucketMetaSearch_ObjStore_S3() {}
~RGWGetBucketMetaSearch_ObjStore_S3() {}
void send_response() override;
};
class RGWDelBucketMetaSearch_ObjStore_S3 : public RGWDelBucketMetaSearch {
public:
RGWDelBucketMetaSearch_ObjStore_S3() {}
~RGWDelBucketMetaSearch_ObjStore_S3() {}
void send_response() override;
};
class RGWGetBucketPolicyStatus_ObjStore_S3 : public RGWGetBucketPolicyStatus {
public:
void send_response() override;
};
class RGWPutBucketPublicAccessBlock_ObjStore_S3 : public RGWPutBucketPublicAccessBlock {
public:
void send_response() override;
};
class RGWGetBucketPublicAccessBlock_ObjStore_S3 : public RGWGetBucketPublicAccessBlock {
public:
void send_response() override;
};
class RGW_Auth_S3 {
public:
static int authorize(const DoutPrefixProvider *dpp,
rgw::sal::Driver* driver,
const rgw::auth::StrategyRegistry& auth_registry,
req_state *s, optional_yield y);
};
class RGWHandler_Auth_S3 : public RGWHandler_REST {
friend class RGWRESTMgr_S3;
const rgw::auth::StrategyRegistry& auth_registry;
public:
explicit RGWHandler_Auth_S3(const rgw::auth::StrategyRegistry& auth_registry)
: RGWHandler_REST(),
auth_registry(auth_registry) {
}
~RGWHandler_Auth_S3() override = default;
static int validate_bucket_name(const std::string& bucket);
static int validate_object_name(const std::string& bucket);
int init(rgw::sal::Driver* driver,
req_state *s,
rgw::io::BasicClient *cio) override;
int authorize(const DoutPrefixProvider *dpp, optional_yield y) override {
return RGW_Auth_S3::authorize(dpp, driver, auth_registry, s, y);
}
int postauth_init(optional_yield) override { return 0; }
};
class RGWHandler_REST_S3 : public RGWHandler_REST {
friend class RGWRESTMgr_S3;
protected:
const rgw::auth::StrategyRegistry& auth_registry;
public:
static int init_from_header(rgw::sal::Driver* driver, req_state *s, RGWFormat default_formatter,
bool configurable_format);
explicit RGWHandler_REST_S3(const rgw::auth::StrategyRegistry& auth_registry)
: RGWHandler_REST(),
auth_registry(auth_registry) {
}
~RGWHandler_REST_S3() override = default;
int init(rgw::sal::Driver* driver,
req_state *s,
rgw::io::BasicClient *cio) override;
int authorize(const DoutPrefixProvider *dpp, optional_yield y) override;
int postauth_init(optional_yield y) override;
};
class RGWHandler_REST_Service_S3 : public RGWHandler_REST_S3 {
protected:
bool is_usage_op() const {
return s->info.args.exists("usage");
}
RGWOp *op_get() override;
RGWOp *op_head() override;
public:
RGWHandler_REST_Service_S3(const rgw::auth::StrategyRegistry& auth_registry) :
RGWHandler_REST_S3(auth_registry) {}
~RGWHandler_REST_Service_S3() override = default;
};
class RGWHandler_REST_Bucket_S3 : public RGWHandler_REST_S3 {
const bool enable_pubsub;
protected:
bool is_acl_op() const {
return s->info.args.exists("acl");
}
bool is_cors_op() const {
return s->info.args.exists("cors");
}
bool is_lc_op() const {
return s->info.args.exists("lifecycle");
}
bool is_obj_update_op() const override {
return is_acl_op() || is_cors_op();
}
bool is_tagging_op() const {
return s->info.args.exists("tagging");
}
bool is_request_payment_op() const {
return s->info.args.exists("requestPayment");
}
bool is_policy_op() const {
return s->info.args.exists("policy");
}
bool is_object_lock_op() const {
return s->info.args.exists("object-lock");
}
bool is_notification_op() const {
if (enable_pubsub) {
return s->info.args.exists("notification");
}
return false;
}
bool is_replication_op() const {
return s->info.args.exists("replication");
}
bool is_policy_status_op() {
return s->info.args.exists("policyStatus");
}
bool is_block_public_access_op() {
return s->info.args.exists("publicAccessBlock");
}
bool is_bucket_encryption_op() {
return s->info.args.exists("encryption");
}
RGWOp *get_obj_op(bool get_data) const;
RGWOp *op_get() override;
RGWOp *op_head() override;
RGWOp *op_put() override;
RGWOp *op_delete() override;
RGWOp *op_post() override;
RGWOp *op_options() override;
public:
RGWHandler_REST_Bucket_S3(const rgw::auth::StrategyRegistry& auth_registry, bool _enable_pubsub) :
RGWHandler_REST_S3(auth_registry), enable_pubsub(_enable_pubsub) {}
~RGWHandler_REST_Bucket_S3() override = default;
};
class RGWHandler_REST_Obj_S3 : public RGWHandler_REST_S3 {
protected:
bool is_acl_op() const {
return s->info.args.exists("acl");
}
bool is_tagging_op() const {
return s->info.args.exists("tagging");
}
bool is_obj_retention_op() const {
return s->info.args.exists("retention");
}
bool is_obj_legal_hold_op() const {
return s->info.args.exists("legal-hold");
}
bool is_select_op() const {
return s->info.args.exists("select-type");
}
bool is_obj_update_op() const override {
return is_acl_op() || is_tagging_op() || is_obj_retention_op() || is_obj_legal_hold_op() || is_select_op();
}
RGWOp *get_obj_op(bool get_data);
RGWOp *op_get() override;
RGWOp *op_head() override;
RGWOp *op_put() override;
RGWOp *op_delete() override;
RGWOp *op_post() override;
RGWOp *op_options() override;
public:
using RGWHandler_REST_S3::RGWHandler_REST_S3;
~RGWHandler_REST_Obj_S3() override = default;
};
class RGWRESTMgr_S3 : public RGWRESTMgr {
private:
const bool enable_s3website;
const bool enable_sts;
const bool enable_iam;
const bool enable_pubsub;
public:
explicit RGWRESTMgr_S3(bool _enable_s3website=false, bool _enable_sts=false, bool _enable_iam=false, bool _enable_pubsub=false)
: enable_s3website(_enable_s3website),
enable_sts(_enable_sts),
enable_iam(_enable_iam),
enable_pubsub(_enable_pubsub) {
}
~RGWRESTMgr_S3() override = default;
RGWHandler_REST *get_handler(rgw::sal::Driver* driver,
req_state* s,
const rgw::auth::StrategyRegistry& auth_registry,
const std::string& frontend_prefix) override;
};
class RGWHandler_REST_Obj_S3Website;
static inline bool looks_like_ip_address(const char *bucket)
{
struct in6_addr a;
if (inet_pton(AF_INET6, bucket, static_cast<void*>(&a)) == 1) {
return true;
}
int num_periods = 0;
bool expect_period = false;
for (const char *b = bucket; *b; ++b) {
if (*b == '.') {
if (!expect_period)
return false;
++num_periods;
if (num_periods > 3)
return false;
expect_period = false;
}
else if (isdigit(*b)) {
expect_period = true;
}
else {
return false;
}
}
return (num_periods == 3);
}
inline int valid_s3_object_name(const std::string& name) {
if (name.size() > 1024) {
return -ERR_INVALID_OBJECT_NAME;
}
if (check_utf8(name.c_str(), name.size())) {
return -ERR_INVALID_OBJECT_NAME;
}
return 0;
}
inline int valid_s3_bucket_name(const std::string& name, bool relaxed=false)
{
// This function enforces Amazon's spec for bucket names.
// (The requirements, not the recommendations.)
int len = name.size();
int max = (relaxed ? 255 : 63);
if (len < 3) {
// Name too short
return -ERR_INVALID_BUCKET_NAME;
} else if (len > max) {
// Name too long
return -ERR_INVALID_BUCKET_NAME;
}
// bucket names must start with a number or letter
if (!(isalpha(name[0]) || isdigit(name[0]))) {
if (!relaxed)
return -ERR_INVALID_BUCKET_NAME;
else if (!(name[0] == '_' || name[0] == '.' || name[0] == '-'))
return -ERR_INVALID_BUCKET_NAME;
}
// bucket names must end with a number or letter
if (!(isalpha(name[len-1]) || isdigit(name[len-1])))
if (!relaxed)
return -ERR_INVALID_BUCKET_NAME;
for (const char *s = name.c_str(); *s; ++s) {
char c = *s;
if (isdigit(c))
continue;
if (isalpha(c)) {
// name cannot contain uppercase letters
if (relaxed || islower(c))
continue;
}
if (c == '_')
// name cannot contain underscore
if (relaxed)
continue;
if (c == '-')
continue;
if (c == '.') {
if (!relaxed && s && *s) {
// name cannot have consecutive periods or dashes
// adjacent to periods
// ensure s is neither the first nor the last character
char p = *(s-1);
char n = *(s+1);
if ((p != '-') && (n != '.') && (n != '-'))
continue;
} else {
continue;
}
}
// Invalid character
return -ERR_INVALID_BUCKET_NAME;
}
if (looks_like_ip_address(name.c_str()))
return -ERR_INVALID_BUCKET_NAME;
return 0;
}
namespace rgw::auth::s3 {
class AWSEngine : public rgw::auth::Engine {
public:
class VersionAbstractor {
static constexpr size_t DIGEST_SIZE_V2 = CEPH_CRYPTO_HMACSHA1_DIGESTSIZE;
static constexpr size_t DIGEST_SIZE_V4 = CEPH_CRYPTO_HMACSHA256_DIGESTSIZE;
/* Knowing the signature max size allows us to employ the sstring, and thus
* avoid dynamic allocations. The multiplier comes from representing digest
* in the base64-encoded form. */
static constexpr size_t SIGNATURE_MAX_SIZE = \
std::max(DIGEST_SIZE_V2, DIGEST_SIZE_V4) * 2 + sizeof('\0');
public:
virtual ~VersionAbstractor() {};
using access_key_id_t = std::string_view;
using client_signature_t = std::string_view;
using session_token_t = std::string_view;
using server_signature_t = basic_sstring<char, uint16_t, SIGNATURE_MAX_SIZE>;
using string_to_sign_t = std::string;
/* Transformation for crafting the AWS signature at server side which is
* used later to compare with the user-provided one. The methodology for
* doing that depends on AWS auth version. */
using signature_factory_t = \
std::function<server_signature_t(CephContext* cct,
const std::string& secret_key,
const string_to_sign_t& string_to_sign)>;
/* Return an instance of Completer for verifying the payload's fingerprint
* if necessary. Otherwise caller gets nullptr. Caller may provide secret
* key */
using completer_factory_t = \
std::function<rgw::auth::Completer::cmplptr_t(
const boost::optional<std::string>& secret_key)>;
struct auth_data_t {
access_key_id_t access_key_id;
client_signature_t client_signature;
session_token_t session_token;
string_to_sign_t string_to_sign;
signature_factory_t signature_factory;
completer_factory_t completer_factory;
};
virtual auth_data_t get_auth_data(const req_state* s) const = 0;
};
protected:
CephContext* cct;
const VersionAbstractor& ver_abstractor;
AWSEngine(CephContext* const cct, const VersionAbstractor& ver_abstractor)
: cct(cct),
ver_abstractor(ver_abstractor) {
}
using result_t = rgw::auth::Engine::result_t;
using string_to_sign_t = VersionAbstractor::string_to_sign_t;
using signature_factory_t = VersionAbstractor::signature_factory_t;
using completer_factory_t = VersionAbstractor::completer_factory_t;
/* TODO(rzarzynski): clean up. We've too many input parameter hee. Also
* the signature get_auth_data() of VersionAbstractor is too complicated.
* Replace these thing with a simple, dedicated structure. */
virtual result_t authenticate(const DoutPrefixProvider* dpp,
const std::string_view& access_key_id,
const std::string_view& signature,
const std::string_view& session_token,
const string_to_sign_t& string_to_sign,
const signature_factory_t& signature_factory,
const completer_factory_t& completer_factory,
const req_state* s,
optional_yield y) const = 0;
public:
result_t authenticate(const DoutPrefixProvider* dpp, const req_state* const s,
optional_yield y) const final;
};
class AWSGeneralAbstractor : public AWSEngine::VersionAbstractor {
CephContext* const cct;
virtual boost::optional<std::string>
get_v4_canonical_headers(const req_info& info,
const std::string_view& signedheaders,
const bool using_qs) const;
auth_data_t get_auth_data_v2(const req_state* s) const;
auth_data_t get_auth_data_v4(const req_state* s, const bool using_qs) const;
public:
explicit AWSGeneralAbstractor(CephContext* const cct)
: cct(cct) {
}
auth_data_t get_auth_data(const req_state* s) const override;
};
class AWSGeneralBoto2Abstractor : public AWSGeneralAbstractor {
boost::optional<std::string>
get_v4_canonical_headers(const req_info& info,
const std::string_view& signedheaders,
const bool using_qs) const override;
public:
using AWSGeneralAbstractor::AWSGeneralAbstractor;
};
class AWSBrowserUploadAbstractor : public AWSEngine::VersionAbstractor {
static std::string to_string(ceph::bufferlist bl) {
return std::string(bl.c_str(),
static_cast<std::string::size_type>(bl.length()));
}
auth_data_t get_auth_data_v2(const req_state* s) const;
auth_data_t get_auth_data_v4(const req_state* s) const;
public:
explicit AWSBrowserUploadAbstractor(CephContext*) {
}
auth_data_t get_auth_data(const req_state* s) const override;
};
class AWSSignerV4 {
const DoutPrefixProvider *dpp;
CephContext *cct;
public:
AWSSignerV4(const DoutPrefixProvider *_dpp) : dpp(_dpp),
cct(_dpp->get_cct()) {}
using access_key_id_t = std::string_view;
using string_to_sign_t = AWSEngine::VersionAbstractor::string_to_sign_t;
using signature_headers_t = std::map<std::string, std::string>;
struct prepare_result_t;
using signature_factory_t = \
std::function<signature_headers_t(const DoutPrefixProvider* dpp,
const std::string& secret_key,
const prepare_result_t&)>;
struct prepare_result_t {
access_key_id_t access_key_id;
std::string date;
std::string scope;
std::string signed_headers;
string_to_sign_t string_to_sign;
std::map<std::string, std::string> extra_headers;
signature_factory_t signature_factory;
};
static prepare_result_t prepare(const DoutPrefixProvider *dpp,
const std::string& access_key_id,
const string& region,
const string& service,
const req_info& info,
const bufferlist *opt_content,
bool s3_op);
};
extern AWSSignerV4::signature_headers_t
gen_v4_signature(const DoutPrefixProvider *dpp,
const std::string_view& secret_key,
const AWSSignerV4::prepare_result_t& sig_info);
class LDAPEngine : public AWSEngine {
static rgw::LDAPHelper* ldh;
static std::mutex mtx;
static void init(CephContext* const cct);
using acl_strategy_t = rgw::auth::RemoteApplier::acl_strategy_t;
using auth_info_t = rgw::auth::RemoteApplier::AuthInfo;
using result_t = rgw::auth::Engine::result_t;
protected:
rgw::sal::Driver* driver;
const rgw::auth::RemoteApplier::Factory* const apl_factory;
acl_strategy_t get_acl_strategy() const;
auth_info_t get_creds_info(const rgw::RGWToken& token) const noexcept;
result_t authenticate(const DoutPrefixProvider* dpp,
const std::string_view& access_key_id,
const std::string_view& signature,
const std::string_view& session_token,
const string_to_sign_t& string_to_sign,
const signature_factory_t&,
const completer_factory_t& completer_factory,
const req_state* s,
optional_yield y) const override;
public:
LDAPEngine(CephContext* const cct,
rgw::sal::Driver* driver,
const VersionAbstractor& ver_abstractor,
const rgw::auth::RemoteApplier::Factory* const apl_factory)
: AWSEngine(cct, ver_abstractor),
driver(driver),
apl_factory(apl_factory) {
init(cct);
}
using AWSEngine::authenticate;
const char* get_name() const noexcept override {
return "rgw::auth::s3::LDAPEngine";
}
static bool valid();
static void shutdown();
};
class LocalEngine : public AWSEngine {
rgw::sal::Driver* driver;
const rgw::auth::LocalApplier::Factory* const apl_factory;
result_t authenticate(const DoutPrefixProvider* dpp,
const std::string_view& access_key_id,
const std::string_view& signature,
const std::string_view& session_token,
const string_to_sign_t& string_to_sign,
const signature_factory_t& signature_factory,
const completer_factory_t& completer_factory,
const req_state* s,
optional_yield y) const override;
public:
LocalEngine(CephContext* const cct,
rgw::sal::Driver* driver,
const VersionAbstractor& ver_abstractor,
const rgw::auth::LocalApplier::Factory* const apl_factory)
: AWSEngine(cct, ver_abstractor),
driver(driver),
apl_factory(apl_factory) {
}
using AWSEngine::authenticate;
const char* get_name() const noexcept override {
return "rgw::auth::s3::LocalEngine";
}
};
class STSEngine : public AWSEngine {
rgw::sal::Driver* driver;
const rgw::auth::LocalApplier::Factory* const local_apl_factory;
const rgw::auth::RemoteApplier::Factory* const remote_apl_factory;
const rgw::auth::RoleApplier::Factory* const role_apl_factory;
using acl_strategy_t = rgw::auth::RemoteApplier::acl_strategy_t;
using auth_info_t = rgw::auth::RemoteApplier::AuthInfo;
acl_strategy_t get_acl_strategy() const { return nullptr; };
auth_info_t get_creds_info(const STS::SessionToken& token) const noexcept;
int get_session_token(const DoutPrefixProvider* dpp, const std::string_view& session_token,
STS::SessionToken& token) const;
result_t authenticate(const DoutPrefixProvider* dpp,
const std::string_view& access_key_id,
const std::string_view& signature,
const std::string_view& session_token,
const string_to_sign_t& string_to_sign,
const signature_factory_t& signature_factory,
const completer_factory_t& completer_factory,
const req_state* s,
optional_yield y) const override;
public:
STSEngine(CephContext* const cct,
rgw::sal::Driver* driver,
const VersionAbstractor& ver_abstractor,
const rgw::auth::LocalApplier::Factory* const local_apl_factory,
const rgw::auth::RemoteApplier::Factory* const remote_apl_factory,
const rgw::auth::RoleApplier::Factory* const role_apl_factory)
: AWSEngine(cct, ver_abstractor),
driver(driver),
local_apl_factory(local_apl_factory),
remote_apl_factory(remote_apl_factory),
role_apl_factory(role_apl_factory) {
}
using AWSEngine::authenticate;
const char* get_name() const noexcept override {
return "rgw::auth::s3::STSEngine";
}
};
class S3AnonymousEngine : public rgw::auth::AnonymousEngine {
bool is_applicable(const req_state* s) const noexcept override;
public:
/* Let's reuse the parent class' constructor. */
using rgw::auth::AnonymousEngine::AnonymousEngine;
const char* get_name() const noexcept override {
return "rgw::auth::s3::S3AnonymousEngine";
}
};
} // namespace rgw::auth::s3
| 36,332 | 28.879112 | 129 |
h
|
null |
ceph-main/src/rgw/rgw_rest_s3website.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2015 Robin H. Johnson <[email protected]>
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#pragma once
#include "rgw_rest_s3.h"
class RGWHandler_REST_S3Website : public RGWHandler_REST_S3 {
std::string original_object_name; // object name before retarget()
bool web_dir() const;
protected:
int retarget(RGWOp *op, RGWOp **new_op, optional_yield y) override;
// TODO: this should be virtual I think, and ensure that it's always
// overridden, but that conflates that op_get/op_head are defined in this
// class and call this; and don't need to be overridden later.
virtual RGWOp *get_obj_op(bool get_data) { return NULL; }
RGWOp *op_get() override;
RGWOp *op_head() override;
// Only allowed to use GET+HEAD
RGWOp *op_put() override { return NULL; }
RGWOp *op_delete() override { return NULL; }
RGWOp *op_post() override { return NULL; }
RGWOp *op_copy() override { return NULL; }
RGWOp *op_options() override { return NULL; }
int serve_errordoc(const DoutPrefixProvider *dpp, int http_ret, const std::string &errordoc_key, optional_yield y);
public:
using RGWHandler_REST_S3::RGWHandler_REST_S3;
~RGWHandler_REST_S3Website() override = default;
int init(rgw::sal::Driver* driver, req_state *s, rgw::io::BasicClient* cio) override;
int error_handler(int err_no, std::string *error_content, optional_yield y) override;
};
class RGWHandler_REST_Service_S3Website : public RGWHandler_REST_S3Website {
protected:
RGWOp *get_obj_op(bool get_data) override;
public:
using RGWHandler_REST_S3Website::RGWHandler_REST_S3Website;
~RGWHandler_REST_Service_S3Website() override = default;
};
class RGWHandler_REST_Obj_S3Website : public RGWHandler_REST_S3Website {
protected:
RGWOp *get_obj_op(bool get_data) override;
public:
using RGWHandler_REST_S3Website::RGWHandler_REST_S3Website;
~RGWHandler_REST_Obj_S3Website() override = default;
};
/* The cross-inheritance from Obj to Bucket is deliberate!
* S3Websites do NOT support any bucket operations
*/
class RGWHandler_REST_Bucket_S3Website : public RGWHandler_REST_S3Website {
protected:
RGWOp *get_obj_op(bool get_data) override;
public:
using RGWHandler_REST_S3Website::RGWHandler_REST_S3Website;
~RGWHandler_REST_Bucket_S3Website() override = default;
};
// TODO: do we actually need this?
class RGWGetObj_ObjStore_S3Website : public RGWGetObj_ObjStore_S3
{
friend class RGWHandler_REST_S3Website;
private:
bool is_errordoc_request;
public:
RGWGetObj_ObjStore_S3Website() : is_errordoc_request(false) {}
explicit RGWGetObj_ObjStore_S3Website(bool is_errordoc_request) : is_errordoc_request(false) { this->is_errordoc_request = is_errordoc_request; }
~RGWGetObj_ObjStore_S3Website() override {}
int send_response_data_error(optional_yield y) override;
int send_response_data(bufferlist& bl, off_t ofs, off_t len) override;
// We override RGWGetObj_ObjStore::get_params here, to allow ignoring all
// conditional params for error pages.
int get_params(optional_yield y) override {
if (is_errordoc_request) {
range_str = NULL;
if_mod = NULL;
if_unmod = NULL;
if_match = NULL;
if_nomatch = NULL;
return 0;
} else {
return RGWGetObj_ObjStore_S3::get_params(y);
}
}
};
| 3,629 | 34.940594 | 147 |
h
|
null |
ceph-main/src/rgw/rgw_rest_sts.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#include <vector>
#include <string>
#include <array>
#include <string_view>
#include <sstream>
#include <memory>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/format.hpp>
#include <boost/optional.hpp>
#include <boost/utility/in_place_factory.hpp>
#include <boost/tokenizer.hpp>
#include "ceph_ver.h"
#include "common/Formatter.h"
#include "common/utf8.h"
#include "common/ceph_json.h"
#include "rgw_rest.h"
#include "rgw_auth.h"
#include "rgw_auth_registry.h"
#include "jwt-cpp/jwt.h"
#include "rgw_rest_sts.h"
#include "rgw_formats.h"
#include "rgw_client_io.h"
#include "rgw_request.h"
#include "rgw_process.h"
#include "rgw_iam_policy.h"
#include "rgw_iam_policy_keywords.h"
#include "rgw_sts.h"
#include "rgw_rest_oidc_provider.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rgw
using namespace std;
namespace rgw::auth::sts {
bool
WebTokenEngine::is_applicable(const std::string& token) const noexcept
{
return ! token.empty();
}
std::string
WebTokenEngine::get_role_tenant(const string& role_arn) const
{
string tenant;
auto r_arn = rgw::ARN::parse(role_arn);
if (r_arn) {
tenant = r_arn->account;
}
return tenant;
}
std::string
WebTokenEngine::get_role_name(const string& role_arn) const
{
string role_name;
auto r_arn = rgw::ARN::parse(role_arn);
if (r_arn) {
role_name = r_arn->resource;
}
if (!role_name.empty()) {
auto pos = role_name.find_last_of('/');
if(pos != string::npos) {
role_name = role_name.substr(pos + 1);
}
}
return role_name;
}
std::unique_ptr<rgw::sal::RGWOIDCProvider>
WebTokenEngine::get_provider(const DoutPrefixProvider *dpp, const string& role_arn, const string& iss, optional_yield y) const
{
string tenant = get_role_tenant(role_arn);
string idp_url = iss;
auto pos = idp_url.find("http://");
if (pos == std::string::npos) {
pos = idp_url.find("https://");
if (pos != std::string::npos) {
idp_url.erase(pos, 8);
} else {
pos = idp_url.find("www.");
if (pos != std::string::npos) {
idp_url.erase(pos, 4);
}
}
} else {
idp_url.erase(pos, 7);
}
auto provider_arn = rgw::ARN(idp_url, "oidc-provider", tenant);
string p_arn = provider_arn.to_string();
std::unique_ptr<rgw::sal::RGWOIDCProvider> provider = driver->get_oidc_provider();
provider->set_arn(p_arn);
provider->set_tenant(tenant);
auto ret = provider->get(dpp, y);
if (ret < 0) {
return nullptr;
}
return provider;
}
bool
WebTokenEngine::is_client_id_valid(vector<string>& client_ids, const string& client_id) const
{
for (auto it : client_ids) {
if (it == client_id) {
return true;
}
}
return false;
}
bool
WebTokenEngine::is_cert_valid(const vector<string>& thumbprints, const string& cert) const
{
//calculate thumbprint of cert
std::unique_ptr<BIO, decltype(&BIO_free_all)> certbio(BIO_new_mem_buf(cert.data(), cert.size()), BIO_free_all);
std::unique_ptr<BIO, decltype(&BIO_free_all)> keybio(BIO_new(BIO_s_mem()), BIO_free_all);
string pw="";
std::unique_ptr<X509, decltype(&X509_free)> x_509cert(PEM_read_bio_X509(certbio.get(), nullptr, nullptr, const_cast<char*>(pw.c_str())), X509_free);
const EVP_MD* fprint_type = EVP_sha1();
unsigned int fprint_size;
unsigned char fprint[EVP_MAX_MD_SIZE];
if (!X509_digest(x_509cert.get(), fprint_type, fprint, &fprint_size)) {
return false;
}
stringstream ss;
for (unsigned int i = 0; i < fprint_size; i++) {
ss << std::setfill('0') << std::setw(2) << std::hex << (0xFF & (unsigned int)fprint[i]);
}
std::string digest = ss.str();
for (auto& it : thumbprints) {
if (boost::iequals(it,digest)) {
return true;
}
}
return false;
}
template <typename T>
void
WebTokenEngine::recurse_and_insert(const string& key, const jwt::claim& c, T& t) const
{
string s_val;
jwt::claim::type c_type = c.get_type();
switch(c_type) {
case jwt::claim::type::null:
break;
case jwt::claim::type::boolean:
case jwt::claim::type::number:
case jwt::claim::type::int64:
{
s_val = c.to_json().serialize();
t.emplace(std::make_pair(key, s_val));
break;
}
case jwt::claim::type::string:
{
s_val = c.to_json().to_str();
t.emplace(std::make_pair(key, s_val));
break;
}
case jwt::claim::type::array:
{
const picojson::array& arr = c.as_array();
for (auto& a : arr) {
recurse_and_insert(key, jwt::claim(a), t);
}
break;
}
case jwt::claim::type::object:
{
const picojson::object& obj = c.as_object();
for (auto& m : obj) {
recurse_and_insert(m.first, jwt::claim(m.second), t);
}
break;
}
}
return;
}
//Extract all token claims so that they can be later used in the Condition element of Role's trust policy
WebTokenEngine::token_t
WebTokenEngine::get_token_claims(const jwt::decoded_jwt& decoded) const
{
WebTokenEngine::token_t token;
const auto& claims = decoded.get_payload_claims();
for (auto& c : claims) {
if (c.first == string(princTagsNamespace)) {
continue;
}
recurse_and_insert(c.first, c.second, token);
}
return token;
}
//Offline validation of incoming Web Token which is a signed JWT (JSON Web Token)
std::tuple<boost::optional<WebTokenEngine::token_t>, boost::optional<WebTokenEngine::principal_tags_t>>
WebTokenEngine::get_from_jwt(const DoutPrefixProvider* dpp, const std::string& token, const req_state* const s,
optional_yield y) const
{
WebTokenEngine::token_t t;
WebTokenEngine::principal_tags_t principal_tags;
try {
const auto& decoded = jwt::decode(token);
auto& payload = decoded.get_payload();
ldpp_dout(dpp, 20) << " payload = " << payload << dendl;
t = get_token_claims(decoded);
string iss;
if (decoded.has_issuer()) {
iss = decoded.get_issuer();
}
set<string> aud;
if (decoded.has_audience()) {
aud = decoded.get_audience();
}
string client_id;
if (decoded.has_payload_claim("client_id")) {
client_id = decoded.get_payload_claim("client_id").as_string();
}
if (client_id.empty() && decoded.has_payload_claim("clientId")) {
client_id = decoded.get_payload_claim("clientId").as_string();
}
string azp;
if (decoded.has_payload_claim("azp")) {
azp = decoded.get_payload_claim("azp").as_string();
}
string role_arn = s->info.args.get("RoleArn");
auto provider = get_provider(dpp, role_arn, iss, y);
if (! provider) {
ldpp_dout(dpp, 0) << "Couldn't get oidc provider info using input iss" << iss << dendl;
throw -EACCES;
}
if (decoded.has_payload_claim(string(princTagsNamespace))) {
auto& cl = decoded.get_payload_claim(string(princTagsNamespace));
if (cl.get_type() == jwt::claim::type::object || cl.get_type() == jwt::claim::type::array) {
recurse_and_insert("dummy", cl, principal_tags);
for (auto it : principal_tags) {
ldpp_dout(dpp, 5) << "Key: " << it.first << " Value: " << it.second << dendl;
}
} else {
ldpp_dout(dpp, 0) << "Malformed principal tags" << cl.as_string() << dendl;
throw -EINVAL;
}
}
vector<string> client_ids = provider->get_client_ids();
vector<string> thumbprints = provider->get_thumbprints();
if (! client_ids.empty()) {
bool found = false;
for (auto& it : aud) {
if (is_client_id_valid(client_ids, it)) {
found = true;
break;
}
}
if (! found && ! is_client_id_valid(client_ids, client_id) && ! is_client_id_valid(client_ids, azp)) {
ldpp_dout(dpp, 0) << "Client id in token doesn't match with that registered with oidc provider" << dendl;
throw -EACCES;
}
}
//Validate signature
if (decoded.has_algorithm()) {
auto& algorithm = decoded.get_algorithm();
try {
validate_signature(dpp, decoded, algorithm, iss, thumbprints, y);
} catch (...) {
throw -EACCES;
}
} else {
return {boost::none, boost::none};
}
} catch (int error) {
if (error == -EACCES) {
throw -EACCES;
}
ldpp_dout(dpp, 5) << "Invalid JWT token" << dendl;
return {boost::none, boost::none};
}
catch (...) {
ldpp_dout(dpp, 5) << "Invalid JWT token" << dendl;
return {boost::none, boost::none};
}
return {t, principal_tags};
}
std::string
WebTokenEngine::get_cert_url(const string& iss, const DoutPrefixProvider *dpp, optional_yield y) const
{
string cert_url;
string openidc_wellknown_url = iss;
bufferlist openidc_resp;
if (openidc_wellknown_url.back() == '/') {
openidc_wellknown_url.pop_back();
}
openidc_wellknown_url.append("/.well-known/openid-configuration");
RGWHTTPTransceiver openidc_req(cct, "GET", openidc_wellknown_url, &openidc_resp);
//Headers
openidc_req.append_header("Content-Type", "application/x-www-form-urlencoded");
int res = openidc_req.process(y);
if (res < 0) {
ldpp_dout(dpp, 10) << "HTTP request res: " << res << dendl;
throw -EINVAL;
}
//Debug only
ldpp_dout(dpp, 20) << "HTTP status: " << openidc_req.get_http_status() << dendl;
ldpp_dout(dpp, 20) << "JSON Response is: " << openidc_resp.c_str() << dendl;
JSONParser parser;
if (parser.parse(openidc_resp.c_str(), openidc_resp.length())) {
JSONObj::data_val val;
if (parser.get_data("jwks_uri", &val)) {
cert_url = val.str.c_str();
ldpp_dout(dpp, 20) << "Cert URL is: " << cert_url.c_str() << dendl;
} else {
ldpp_dout(dpp, 0) << "Malformed json returned while fetching openidc url" << dendl;
}
}
return cert_url;
}
void
WebTokenEngine::validate_signature(const DoutPrefixProvider* dpp, const jwt::decoded_jwt& decoded, const string& algorithm, const string& iss, const vector<string>& thumbprints, optional_yield y) const
{
if (algorithm != "HS256" && algorithm != "HS384" && algorithm != "HS512") {
string cert_url = get_cert_url(iss, dpp, y);
if (cert_url.empty()) {
throw -EINVAL;
}
// Get certificate
bufferlist cert_resp;
RGWHTTPTransceiver cert_req(cct, "GET", cert_url, &cert_resp);
//Headers
cert_req.append_header("Content-Type", "application/x-www-form-urlencoded");
int res = cert_req.process(y);
if (res < 0) {
ldpp_dout(dpp, 10) << "HTTP request res: " << res << dendl;
throw -EINVAL;
}
//Debug only
ldpp_dout(dpp, 20) << "HTTP status: " << cert_req.get_http_status() << dendl;
ldpp_dout(dpp, 20) << "JSON Response is: " << cert_resp.c_str() << dendl;
JSONParser parser;
if (parser.parse(cert_resp.c_str(), cert_resp.length())) {
JSONObj::data_val val;
if (parser.get_data("keys", &val)) {
if (val.str[0] == '[') {
val.str.erase(0, 1);
}
if (val.str[val.str.size() - 1] == ']') {
val.str = val.str.erase(val.str.size() - 1, 1);
}
if (parser.parse(val.str.c_str(), val.str.size())) {
vector<string> x5c;
if (JSONDecoder::decode_json("x5c", x5c, &parser)) {
string cert;
bool found_valid_cert = false;
for (auto& it : x5c) {
cert = "-----BEGIN CERTIFICATE-----\n" + it + "\n-----END CERTIFICATE-----";
ldpp_dout(dpp, 20) << "Certificate is: " << cert.c_str() << dendl;
if (is_cert_valid(thumbprints, cert)) {
found_valid_cert = true;
break;
}
found_valid_cert = true;
}
if (! found_valid_cert) {
ldpp_dout(dpp, 0) << "Cert doesn't match that with the thumbprints registered with oidc provider: " << cert.c_str() << dendl;
throw -EINVAL;
}
try {
//verify method takes care of expired tokens also
if (algorithm == "RS256") {
auto verifier = jwt::verify()
.allow_algorithm(jwt::algorithm::rs256{cert});
verifier.verify(decoded);
} else if (algorithm == "RS384") {
auto verifier = jwt::verify()
.allow_algorithm(jwt::algorithm::rs384{cert});
verifier.verify(decoded);
} else if (algorithm == "RS512") {
auto verifier = jwt::verify()
.allow_algorithm(jwt::algorithm::rs512{cert});
verifier.verify(decoded);
} else if (algorithm == "ES256") {
auto verifier = jwt::verify()
.allow_algorithm(jwt::algorithm::es256{cert});
verifier.verify(decoded);
} else if (algorithm == "ES384") {
auto verifier = jwt::verify()
.allow_algorithm(jwt::algorithm::es384{cert});
verifier.verify(decoded);
} else if (algorithm == "ES512") {
auto verifier = jwt::verify()
.allow_algorithm(jwt::algorithm::es512{cert});
verifier.verify(decoded);
} else if (algorithm == "PS256") {
auto verifier = jwt::verify()
.allow_algorithm(jwt::algorithm::ps256{cert});
verifier.verify(decoded);
} else if (algorithm == "PS384") {
auto verifier = jwt::verify()
.allow_algorithm(jwt::algorithm::ps384{cert});
verifier.verify(decoded);
} else if (algorithm == "PS512") {
auto verifier = jwt::verify()
.allow_algorithm(jwt::algorithm::ps512{cert});
verifier.verify(decoded);
}
} catch (std::runtime_error& e) {
ldpp_dout(dpp, 0) << "Signature validation failed: " << e.what() << dendl;
throw;
}
catch (...) {
ldpp_dout(dpp, 0) << "Signature validation failed" << dendl;
throw;
}
} else {
ldpp_dout(dpp, 0) << "x5c not present" << dendl;
throw -EINVAL;
}
} else {
ldpp_dout(dpp, 0) << "Malformed JSON object for keys" << dendl;
throw -EINVAL;
}
} else {
ldpp_dout(dpp, 0) << "keys not present in JSON" << dendl;
throw -EINVAL;
} //if-else get-data
} else {
ldpp_dout(dpp, 0) << "Malformed json returned while fetching cert" << dendl;
throw -EINVAL;
} //if-else parser cert_resp
} else {
ldpp_dout(dpp, 0) << "JWT signed by HMAC algos are currently not supported" << dendl;
throw -EINVAL;
}
}
WebTokenEngine::result_t
WebTokenEngine::authenticate( const DoutPrefixProvider* dpp,
const std::string& token,
const req_state* const s,
optional_yield y) const
{
if (! is_applicable(token)) {
return result_t::deny();
}
try {
auto [t, princ_tags] = get_from_jwt(dpp, token, s, y);
if (t) {
string role_session = s->info.args.get("RoleSessionName");
if (role_session.empty()) {
ldout(s->cct, 0) << "Role Session Name is empty " << dendl;
return result_t::deny(-EACCES);
}
string role_arn = s->info.args.get("RoleArn");
string role_tenant = get_role_tenant(role_arn);
string role_name = get_role_name(role_arn);
std::unique_ptr<rgw::sal::RGWRole> role = driver->get_role(role_name, role_tenant);
int ret = role->get(dpp, y);
if (ret < 0) {
ldpp_dout(dpp, 0) << "Role not found: name:" << role_name << " tenant: " << role_tenant << dendl;
return result_t::deny(-EACCES);
}
boost::optional<multimap<string,string>> role_tags = role->get_tags();
auto apl = apl_factory->create_apl_web_identity(cct, s, role_session, role_tenant, *t, role_tags, princ_tags);
return result_t::grant(std::move(apl));
}
return result_t::deny(-EACCES);
}
catch (...) {
return result_t::deny(-EACCES);
}
}
} // namespace rgw::auth::sts
int RGWREST_STS::verify_permission(optional_yield y)
{
STS::STSService _sts(s->cct, driver, s->user->get_id(), s->auth.identity.get());
sts = std::move(_sts);
string rArn = s->info.args.get("RoleArn");
const auto& [ret, role] = sts.getRoleInfo(s, rArn, y);
if (ret < 0) {
ldpp_dout(this, 0) << "failed to get role info using role arn: " << rArn << dendl;
return ret;
}
string policy = role->get_assume_role_policy();
buffer::list bl = buffer::list::static_from_string(policy);
//Parse the policy
//TODO - This step should be part of Role Creation
try {
const rgw::IAM::Policy p(s->cct, s->user->get_tenant(), bl, false);
if (!s->principal_tags.empty()) {
auto res = p.eval(s->env, *s->auth.identity, rgw::IAM::stsTagSession, boost::none);
if (res != rgw::IAM::Effect::Allow) {
ldout(s->cct, 0) << "evaluating policy for stsTagSession returned deny/pass" << dendl;
return -EPERM;
}
}
uint64_t op;
if (get_type() == RGW_STS_ASSUME_ROLE_WEB_IDENTITY) {
op = rgw::IAM::stsAssumeRoleWithWebIdentity;
} else {
op = rgw::IAM::stsAssumeRole;
}
auto res = p.eval(s->env, *s->auth.identity, op, boost::none);
if (res != rgw::IAM::Effect::Allow) {
ldout(s->cct, 0) << "evaluating policy for op: " << op << " returned deny/pass" << dendl;
return -EPERM;
}
} catch (rgw::IAM::PolicyParseException& e) {
ldpp_dout(this, 0) << "failed to parse policy: " << e.what() << dendl;
return -EPERM;
}
return 0;
}
void RGWREST_STS::send_response()
{
if (op_ret) {
set_req_state_err(s, op_ret);
}
dump_errno(s);
end_header(s);
}
int RGWSTSGetSessionToken::verify_permission(optional_yield y)
{
rgw::Partition partition = rgw::Partition::aws;
rgw::Service service = rgw::Service::s3;
if (!verify_user_permission(this,
s,
rgw::ARN(partition, service, "", s->user->get_tenant(), ""),
rgw::IAM::stsGetSessionToken)) {
ldpp_dout(this, 0) << "User does not have permssion to perform GetSessionToken" << dendl;
return -EACCES;
}
return 0;
}
int RGWSTSGetSessionToken::get_params()
{
duration = s->info.args.get("DurationSeconds");
serialNumber = s->info.args.get("SerialNumber");
tokenCode = s->info.args.get("TokenCode");
if (! duration.empty()) {
string err;
uint64_t duration_in_secs = strict_strtoll(duration.c_str(), 10, &err);
if (!err.empty()) {
ldpp_dout(this, 0) << "Invalid value of input duration: " << duration << dendl;
return -EINVAL;
}
if (duration_in_secs < STS::GetSessionTokenRequest::getMinDuration() ||
duration_in_secs > s->cct->_conf->rgw_sts_max_session_duration) {
ldpp_dout(this, 0) << "Invalid duration in secs: " << duration_in_secs << dendl;
return -EINVAL;
}
}
return 0;
}
void RGWSTSGetSessionToken::execute(optional_yield y)
{
if (op_ret = get_params(); op_ret < 0) {
return;
}
STS::STSService sts(s->cct, driver, s->user->get_id(), s->auth.identity.get());
STS::GetSessionTokenRequest req(duration, serialNumber, tokenCode);
const auto& [ret, creds] = sts.getSessionToken(this, req);
op_ret = std::move(ret);
//Dump the output
if (op_ret == 0) {
s->formatter->open_object_section("GetSessionTokenResponse");
s->formatter->open_object_section("GetSessionTokenResult");
s->formatter->open_object_section("Credentials");
creds.dump(s->formatter);
s->formatter->close_section();
s->formatter->close_section();
s->formatter->close_section();
}
}
int RGWSTSAssumeRoleWithWebIdentity::get_params()
{
duration = s->info.args.get("DurationSeconds");
providerId = s->info.args.get("ProviderId");
policy = s->info.args.get("Policy");
roleArn = s->info.args.get("RoleArn");
roleSessionName = s->info.args.get("RoleSessionName");
iss = s->info.args.get("provider_id");
sub = s->info.args.get("sub");
aud = s->info.args.get("aud");
if (roleArn.empty() || roleSessionName.empty() || sub.empty() || aud.empty()) {
ldpp_dout(this, 0) << "ERROR: one of role arn or role session name or token is empty" << dendl;
return -EINVAL;
}
if (! policy.empty()) {
bufferlist bl = bufferlist::static_from_string(policy);
try {
const rgw::IAM::Policy p(
s->cct, s->user->get_tenant(), bl,
s->cct->_conf.get_val<bool>("rgw_policy_reject_invalid_principals"));
}
catch (rgw::IAM::PolicyParseException& e) {
ldpp_dout(this, 5) << "failed to parse policy: " << e.what() << "policy" << policy << dendl;
s->err.message = e.what();
return -ERR_MALFORMED_DOC;
}
}
return 0;
}
void RGWSTSAssumeRoleWithWebIdentity::execute(optional_yield y)
{
if (op_ret = get_params(); op_ret < 0) {
return;
}
STS::AssumeRoleWithWebIdentityRequest req(s->cct, duration, providerId, policy, roleArn,
roleSessionName, iss, sub, aud, s->principal_tags);
STS::AssumeRoleWithWebIdentityResponse response = sts.assumeRoleWithWebIdentity(this, req);
op_ret = std::move(response.assumeRoleResp.retCode);
//Dump the output
if (op_ret == 0) {
s->formatter->open_object_section("AssumeRoleWithWebIdentityResponse");
s->formatter->open_object_section("AssumeRoleWithWebIdentityResult");
encode_json("SubjectFromWebIdentityToken", response.sub , s->formatter);
encode_json("Audience", response.aud , s->formatter);
s->formatter->open_object_section("AssumedRoleUser");
response.assumeRoleResp.user.dump(s->formatter);
s->formatter->close_section();
s->formatter->open_object_section("Credentials");
response.assumeRoleResp.creds.dump(s->formatter);
s->formatter->close_section();
encode_json("Provider", response.providerId , s->formatter);
encode_json("PackedPolicySize", response.assumeRoleResp.packedPolicySize , s->formatter);
s->formatter->close_section();
s->formatter->close_section();
}
}
int RGWSTSAssumeRole::get_params()
{
duration = s->info.args.get("DurationSeconds");
externalId = s->info.args.get("ExternalId");
policy = s->info.args.get("Policy");
roleArn = s->info.args.get("RoleArn");
roleSessionName = s->info.args.get("RoleSessionName");
serialNumber = s->info.args.get("SerialNumber");
tokenCode = s->info.args.get("TokenCode");
if (roleArn.empty() || roleSessionName.empty()) {
ldpp_dout(this, 0) << "ERROR: one of role arn or role session name is empty" << dendl;
return -EINVAL;
}
if (! policy.empty()) {
bufferlist bl = bufferlist::static_from_string(policy);
try {
const rgw::IAM::Policy p(
s->cct, s->user->get_tenant(), bl,
s->cct->_conf.get_val<bool>("rgw_policy_reject_invalid_principals"));
}
catch (rgw::IAM::PolicyParseException& e) {
ldpp_dout(this, 0) << "failed to parse policy: " << e.what() << "policy" << policy << dendl;
s->err.message = e.what();
return -ERR_MALFORMED_DOC;
}
}
return 0;
}
void RGWSTSAssumeRole::execute(optional_yield y)
{
if (op_ret = get_params(); op_ret < 0) {
return;
}
STS::AssumeRoleRequest req(s->cct, duration, externalId, policy, roleArn,
roleSessionName, serialNumber, tokenCode);
STS::AssumeRoleResponse response = sts.assumeRole(s, req, y);
op_ret = std::move(response.retCode);
//Dump the output
if (op_ret == 0) {
s->formatter->open_object_section("AssumeRoleResponse");
s->formatter->open_object_section("AssumeRoleResult");
s->formatter->open_object_section("Credentials");
response.creds.dump(s->formatter);
s->formatter->close_section();
s->formatter->open_object_section("AssumedRoleUser");
response.user.dump(s->formatter);
s->formatter->close_section();
encode_json("PackedPolicySize", response.packedPolicySize , s->formatter);
s->formatter->close_section();
s->formatter->close_section();
}
}
int RGW_Auth_STS::authorize(const DoutPrefixProvider *dpp,
rgw::sal::Driver* driver,
const rgw::auth::StrategyRegistry& auth_registry,
req_state *s, optional_yield y)
{
return rgw::auth::Strategy::apply(dpp, auth_registry.get_sts(), s, y);
}
using op_generator = RGWOp*(*)();
static const std::unordered_map<std::string_view, op_generator> op_generators = {
{"AssumeRole", []() -> RGWOp* {return new RGWSTSAssumeRole;}},
{"GetSessionToken", []() -> RGWOp* {return new RGWSTSGetSessionToken;}},
{"AssumeRoleWithWebIdentity", []() -> RGWOp* {return new RGWSTSAssumeRoleWithWebIdentity;}}
};
bool RGWHandler_REST_STS::action_exists(const req_state* s)
{
if (s->info.args.exists("Action")) {
const std::string action_name = s->info.args.get("Action");
return op_generators.contains(action_name);
}
return false;
}
RGWOp *RGWHandler_REST_STS::op_post()
{
if (s->info.args.exists("Action")) {
const std::string action_name = s->info.args.get("Action");
const auto action_it = op_generators.find(action_name);
if (action_it != op_generators.end()) {
return action_it->second();
}
ldpp_dout(s, 10) << "unknown action '" << action_name << "' for STS handler" << dendl;
} else {
ldpp_dout(s, 10) << "missing action argument in STS handler" << dendl;
}
return nullptr;
}
int RGWHandler_REST_STS::init(rgw::sal::Driver* driver,
req_state *s,
rgw::io::BasicClient *cio)
{
s->dialect = "sts";
s->prot_flags = RGW_REST_STS;
return RGWHandler_REST::init(driver, s, cio);
}
int RGWHandler_REST_STS::authorize(const DoutPrefixProvider* dpp, optional_yield y)
{
if (s->info.args.exists("Action") && s->info.args.get("Action") == "AssumeRoleWithWebIdentity") {
return RGW_Auth_STS::authorize(dpp, driver, auth_registry, s, y);
}
return RGW_Auth_S3::authorize(dpp, driver, auth_registry, s, y);
}
RGWHandler_REST*
RGWRESTMgr_STS::get_handler(rgw::sal::Driver* driver,
req_state* const s,
const rgw::auth::StrategyRegistry& auth_registry,
const std::string& frontend_prefix)
{
return new RGWHandler_REST_STS(auth_registry);
}
| 26,562 | 31.393902 | 201 |
cc
|
null |
ceph-main/src/rgw/rgw_rest_sts.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#pragma once
#include "rgw_auth.h"
#include "rgw_auth_filters.h"
#include "rgw_rest.h"
#include "rgw_sts.h"
#include "rgw_web_idp.h"
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
#include "jwt-cpp/jwt.h"
#pragma clang diagnostic pop
#pragma GCC diagnostic pop
#include "rgw_oidc_provider.h"
namespace rgw::auth::sts {
class WebTokenEngine : public rgw::auth::Engine {
static constexpr std::string_view princTagsNamespace = "https://aws.amazon.com/tags";
CephContext* const cct;
rgw::sal::Driver* driver;
using result_t = rgw::auth::Engine::result_t;
using Pair = std::pair<std::string, std::string>;
using token_t = std::unordered_multimap<string, string>;
using principal_tags_t = std::set<Pair>;
const rgw::auth::TokenExtractor* const extractor;
const rgw::auth::WebIdentityApplier::Factory* const apl_factory;
bool is_applicable(const std::string& token) const noexcept;
bool is_client_id_valid(std::vector<std::string>& client_ids, const std::string& client_id) const;
bool is_cert_valid(const std::vector<std::string>& thumbprints, const std::string& cert) const;
std::unique_ptr<rgw::sal::RGWOIDCProvider> get_provider(const DoutPrefixProvider *dpp, const std::string& role_arn, const std::string& iss, optional_yield y) const;
std::string get_role_tenant(const std::string& role_arn) const;
std::string get_role_name(const string& role_arn) const;
std::string get_cert_url(const std::string& iss, const DoutPrefixProvider *dpp,optional_yield y) const;
std::tuple<boost::optional<WebTokenEngine::token_t>, boost::optional<WebTokenEngine::principal_tags_t>>
get_from_jwt(const DoutPrefixProvider* dpp, const std::string& token, const req_state* const s, optional_yield y) const;
void validate_signature (const DoutPrefixProvider* dpp, const jwt::decoded_jwt& decoded, const std::string& algorithm, const std::string& iss, const std::vector<std::string>& thumbprints, optional_yield y) const;
result_t authenticate(const DoutPrefixProvider* dpp,
const std::string& token,
const req_state* s, optional_yield y) const;
template <typename T>
void recurse_and_insert(const string& key, const jwt::claim& c, T& t) const;
WebTokenEngine::token_t get_token_claims(const jwt::decoded_jwt& decoded) const;
public:
WebTokenEngine(CephContext* const cct,
rgw::sal::Driver* driver,
const rgw::auth::TokenExtractor* const extractor,
const rgw::auth::WebIdentityApplier::Factory* const apl_factory)
: cct(cct),
driver(driver),
extractor(extractor),
apl_factory(apl_factory) {
}
const char* get_name() const noexcept override {
return "rgw::auth::sts::WebTokenEngine";
}
result_t authenticate(const DoutPrefixProvider* dpp, const req_state* const s, optional_yield y) const override {
return authenticate(dpp, extractor->get_token(s), s, y);
}
}; /* class WebTokenEngine */
class DefaultStrategy : public rgw::auth::Strategy,
public rgw::auth::TokenExtractor,
public rgw::auth::WebIdentityApplier::Factory {
rgw::sal::Driver* driver;
const ImplicitTenants& implicit_tenant_context;
/* The engine. */
const WebTokenEngine web_token_engine;
using aplptr_t = rgw::auth::IdentityApplier::aplptr_t;
/* The method implements TokenExtractor for Web Token in req_state. */
std::string get_token(const req_state* const s) const override {
return s->info.args.get("WebIdentityToken");
}
aplptr_t create_apl_web_identity( CephContext* cct,
const req_state* s,
const std::string& role_session,
const std::string& role_tenant,
const std::unordered_multimap<std::string, std::string>& token,
boost::optional<std::multimap<std::string, std::string>> role_tags,
boost::optional<std::set<std::pair<std::string, std::string>>> principal_tags) const override {
auto apl = rgw::auth::add_sysreq(cct, driver, s,
rgw::auth::WebIdentityApplier(cct, driver, role_session, role_tenant, token, role_tags, principal_tags));
return aplptr_t(new decltype(apl)(std::move(apl)));
}
public:
DefaultStrategy(CephContext* const cct,
const ImplicitTenants& implicit_tenant_context,
rgw::sal::Driver* driver)
: driver(driver),
implicit_tenant_context(implicit_tenant_context),
web_token_engine(cct, driver,
static_cast<rgw::auth::TokenExtractor*>(this),
static_cast<rgw::auth::WebIdentityApplier::Factory*>(this)) {
/* When the constructor's body is being executed, all member engines
* should be initialized. Thus, we can safely add them. */
using Control = rgw::auth::Strategy::Control;
add_engine(Control::SUFFICIENT, web_token_engine);
}
const char* get_name() const noexcept override {
return "rgw::auth::sts::DefaultStrategy";
}
};
} // namespace rgw::auth::sts
class RGWREST_STS : public RGWRESTOp {
protected:
STS::STSService sts;
public:
RGWREST_STS() = default;
int verify_permission(optional_yield y) override;
void send_response() override;
};
class RGWSTSAssumeRoleWithWebIdentity : public RGWREST_STS {
protected:
std::string duration;
std::string providerId;
std::string policy;
std::string roleArn;
std::string roleSessionName;
std::string sub;
std::string aud;
std::string iss;
public:
RGWSTSAssumeRoleWithWebIdentity() = default;
void execute(optional_yield y) override;
int get_params();
const char* name() const override { return "assume_role_web_identity"; }
RGWOpType get_type() override { return RGW_STS_ASSUME_ROLE_WEB_IDENTITY; }
};
class RGWSTSAssumeRole : public RGWREST_STS {
protected:
std::string duration;
std::string externalId;
std::string policy;
std::string roleArn;
std::string roleSessionName;
std::string serialNumber;
std::string tokenCode;
public:
RGWSTSAssumeRole() = default;
void execute(optional_yield y) override;
int get_params();
const char* name() const override { return "assume_role"; }
RGWOpType get_type() override { return RGW_STS_ASSUME_ROLE; }
};
class RGWSTSGetSessionToken : public RGWREST_STS {
protected:
std::string duration;
std::string serialNumber;
std::string tokenCode;
public:
RGWSTSGetSessionToken() = default;
void execute(optional_yield y) override;
int verify_permission(optional_yield y) override;
int get_params();
const char* name() const override { return "get_session_token"; }
RGWOpType get_type() override { return RGW_STS_GET_SESSION_TOKEN; }
};
class RGW_Auth_STS {
public:
static int authorize(const DoutPrefixProvider *dpp,
rgw::sal::Driver* driver,
const rgw::auth::StrategyRegistry& auth_registry,
req_state *s, optional_yield y);
};
class RGWHandler_REST_STS : public RGWHandler_REST {
const rgw::auth::StrategyRegistry& auth_registry;
RGWOp *op_post() override;
public:
static bool action_exists(const req_state* s);
RGWHandler_REST_STS(const rgw::auth::StrategyRegistry& auth_registry)
: RGWHandler_REST(),
auth_registry(auth_registry) {}
~RGWHandler_REST_STS() override = default;
int init(rgw::sal::Driver* driver,
req_state *s,
rgw::io::BasicClient *cio) override;
int authorize(const DoutPrefixProvider* dpp, optional_yield y) override;
int postauth_init(optional_yield y) override { return 0; }
};
class RGWRESTMgr_STS : public RGWRESTMgr {
public:
RGWRESTMgr_STS() = default;
~RGWRESTMgr_STS() override = default;
RGWRESTMgr *get_resource_mgr(req_state* const s,
const std::string& uri,
std::string* const out_uri) override {
return this;
}
RGWHandler_REST* get_handler(rgw::sal::Driver* driver,
req_state*,
const rgw::auth::StrategyRegistry&,
const std::string&) override;
};
| 8,472 | 34.902542 | 214 |
h
|
null |
ceph-main/src/rgw/rgw_rest_swift.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#include <boost/algorithm/string/predicate.hpp>
#include <boost/format.hpp>
#include <boost/optional.hpp>
#include <boost/utility/in_place_factory.hpp>
#include "include/ceph_assert.h"
#include "ceph_ver.h"
#include "common/Formatter.h"
#include "common/utf8.h"
#include "common/ceph_json.h"
#include "rgw_rest_swift.h"
#include "rgw_acl_swift.h"
#include "rgw_cors_swift.h"
#include "rgw_formats.h"
#include "rgw_client_io.h"
#include "rgw_compression.h"
#include "rgw_auth.h"
#include "rgw_auth_registry.h"
#include "rgw_swift_auth.h"
#include "rgw_request.h"
#include "rgw_process.h"
#include "rgw_zone.h"
#include "rgw_sal.h"
#include "services/svc_zone.h"
#include <array>
#include <string_view>
#include <sstream>
#include <memory>
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rgw
using namespace std;
int RGWListBuckets_ObjStore_SWIFT::get_params(optional_yield y)
{
prefix = s->info.args.get("prefix");
marker = s->info.args.get("marker");
end_marker = s->info.args.get("end_marker");
wants_reversed = s->info.args.exists("reverse");
if (wants_reversed) {
std::swap(marker, end_marker);
}
std::string limit_str = s->info.args.get("limit");
if (!limit_str.empty()) {
std::string err;
long l = strict_strtol(limit_str.c_str(), 10, &err);
if (!err.empty()) {
return -EINVAL;
}
if (l > (long)limit_max || l < 0) {
return -ERR_PRECONDITION_FAILED;
}
limit = (uint64_t)l;
}
if (s->cct->_conf->rgw_swift_need_stats) {
bool stats, exists;
int r = s->info.args.get_bool("stats", &stats, &exists);
if (r < 0) {
return r;
}
if (exists) {
need_stats = stats;
}
} else {
need_stats = false;
}
return 0;
}
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,
const RGWQuotaInfo& quota,
int32_t max_buckets,
const RGWAccessControlPolicy_SWIFTAcct &policy)
{
/* Adding X-Timestamp to keep align with Swift API */
dump_header(s, "X-Timestamp", ceph_clock_now());
dump_header(s, "X-Account-Container-Count", global_stats.buckets_count);
dump_header(s, "X-Account-Object-Count", global_stats.objects_count);
dump_header(s, "X-Account-Bytes-Used", global_stats.bytes_used);
dump_header(s, "X-Account-Bytes-Used-Actual", global_stats.bytes_used_rounded);
for (const auto& kv : policies_stats) {
const auto& policy_name = camelcase_dash_http_attr(kv.first);
const auto& policy_stats = kv.second;
dump_header_infixed(s, "X-Account-Storage-Policy-", policy_name,
"-Container-Count", policy_stats.buckets_count);
dump_header_infixed(s, "X-Account-Storage-Policy-", policy_name,
"-Object-Count", policy_stats.objects_count);
dump_header_infixed(s, "X-Account-Storage-Policy-", policy_name,
"-Bytes-Used", policy_stats.bytes_used);
dump_header_infixed(s, "X-Account-Storage-Policy-", policy_name,
"-Bytes-Used-Actual", policy_stats.bytes_used_rounded);
}
/* Dump TempURL-related stuff */
if (s->perm_mask == RGW_PERM_FULL_CONTROL) {
auto iter = s->user->get_info().temp_url_keys.find(0);
if (iter != std::end(s->user->get_info().temp_url_keys) && ! iter->second.empty()) {
dump_header(s, "X-Account-Meta-Temp-Url-Key", iter->second);
}
iter = s->user->get_info().temp_url_keys.find(1);
if (iter != std::end(s->user->get_info().temp_url_keys) && ! iter->second.empty()) {
dump_header(s, "X-Account-Meta-Temp-Url-Key-2", iter->second);
}
}
/* Dump quota headers. */
if (quota.enabled) {
if (quota.max_size >= 0) {
dump_header(s, "X-Account-Meta-Quota-Bytes", quota.max_size);
}
/* Limit on the number of objects in a given account is a RadosGW's
* extension. Swift's account quota WSGI filter doesn't support it. */
if (quota.max_objects >= 0) {
dump_header(s, "X-Account-Meta-Quota-Count", quota.max_objects);
}
}
/* Limit on the number of containers in a given account is a RadosGW's
* extension. Swift's account quota WSGI filter doesn't support it. */
if (max_buckets >= 0) {
dump_header(s, "X-Account-Meta-Quota-Containers", max_buckets);
}
/* Dump user-defined metadata items and generic attrs. */
const size_t PREFIX_LEN = sizeof(RGW_ATTR_META_PREFIX) - 1;
map<string, bufferlist>::iterator iter;
for (iter = attrs.lower_bound(RGW_ATTR_PREFIX); iter != attrs.end(); ++iter) {
const char *name = iter->first.c_str();
map<string, string>::const_iterator geniter = rgw_to_http_attrs.find(name);
if (geniter != rgw_to_http_attrs.end()) {
dump_header(s, geniter->second, iter->second);
} else if (strncmp(name, RGW_ATTR_META_PREFIX, PREFIX_LEN) == 0) {
dump_header_prefixed(s, "X-Account-Meta-",
camelcase_dash_http_attr(name + PREFIX_LEN),
iter->second);
}
}
/* Dump account ACLs */
auto account_acls = policy.to_str();
if (account_acls) {
dump_header(s, "X-Account-Access-Control", std::move(*account_acls));
}
}
void RGWListBuckets_ObjStore_SWIFT::send_response_begin(bool has_buckets)
{
if (op_ret) {
set_req_state_err(s, op_ret);
} else if (!has_buckets && s->format == RGWFormat::PLAIN) {
op_ret = STATUS_NO_CONTENT;
set_req_state_err(s, op_ret);
}
if (! s->cct->_conf->rgw_swift_enforce_content_length) {
/* Adding account stats in the header to keep align with Swift API */
dump_account_metadata(s,
global_stats,
policies_stats,
s->user->get_attrs(),
s->user->get_info().quota.user_quota,
s->user->get_max_buckets(),
static_cast<RGWAccessControlPolicy_SWIFTAcct&>(*s->user_acl));
dump_errno(s);
dump_header(s, "Accept-Ranges", "bytes");
end_header(s, NULL, NULL, NO_CONTENT_LENGTH, true);
}
if (! op_ret) {
dump_start(s);
s->formatter->open_array_section_with_attrs("account",
FormatterAttrs("name", s->user->get_display_name().c_str(), NULL));
sent_data = true;
}
}
void RGWListBuckets_ObjStore_SWIFT::handle_listing_chunk(rgw::sal::BucketList&& buckets)
{
if (wants_reversed) {
/* Just store in the reversal buffer. Its content will be handled later,
* in send_response_end(). */
reverse_buffer.emplace(std::begin(reverse_buffer), std::move(buckets));
} else {
return send_response_data(buckets);
}
}
void RGWListBuckets_ObjStore_SWIFT::send_response_data(rgw::sal::BucketList& buckets)
{
if (! sent_data) {
return;
}
/* Take care of the prefix parameter of Swift API. There is no business
* in applying the filter earlier as we really need to go through all
* entries regardless of it (the headers like X-Account-Container-Count
* aren't affected by specifying prefix). */
const auto& m = buckets.get_buckets();
for (auto iter = m.lower_bound(prefix);
iter != m.end() && boost::algorithm::starts_with(iter->first, prefix);
++iter) {
dump_bucket_entry(*iter->second);
}
}
void RGWListBuckets_ObjStore_SWIFT::dump_bucket_entry(const rgw::sal::Bucket& bucket)
{
s->formatter->open_object_section("container");
s->formatter->dump_string("name", bucket.get_name());
if (need_stats) {
s->formatter->dump_int("count", bucket.get_count());
s->formatter->dump_int("bytes", bucket.get_size());
}
s->formatter->close_section();
if (! s->cct->_conf->rgw_swift_enforce_content_length) {
rgw_flush_formatter(s, s->formatter);
}
}
void RGWListBuckets_ObjStore_SWIFT::send_response_data_reversed(rgw::sal::BucketList& buckets)
{
if (! sent_data) {
return;
}
/* Take care of the prefix parameter of Swift API. There is no business
* in applying the filter earlier as we really need to go through all
* entries regardless of it (the headers like X-Account-Container-Count
* aren't affected by specifying prefix). */
auto& m = buckets.get_buckets();
auto iter = m.rbegin();
for (/* initialized above */;
iter != m.rend() && !boost::algorithm::starts_with(iter->first, prefix);
++iter) {
/* NOP */;
}
for (/* iter carried */;
iter != m.rend() && boost::algorithm::starts_with(iter->first, prefix);
++iter) {
dump_bucket_entry(*iter->second);
}
}
void RGWListBuckets_ObjStore_SWIFT::send_response_end()
{
if (wants_reversed) {
for (auto& buckets : reverse_buffer) {
send_response_data_reversed(buckets);
}
}
if (sent_data) {
s->formatter->close_section();
}
if (s->cct->_conf->rgw_swift_enforce_content_length) {
/* Adding account stats in the header to keep align with Swift API */
dump_account_metadata(s,
global_stats,
policies_stats,
s->user->get_attrs(),
s->user->get_info().quota.user_quota,
s->user->get_max_buckets(),
static_cast<RGWAccessControlPolicy_SWIFTAcct&>(*s->user_acl));
dump_errno(s);
end_header(s, nullptr, nullptr, s->formatter->get_len(), true);
}
if (sent_data || s->cct->_conf->rgw_swift_enforce_content_length) {
rgw_flush_formatter_and_reset(s, s->formatter);
}
}
int RGWListBucket_ObjStore_SWIFT::get_params(optional_yield y)
{
prefix = s->info.args.get("prefix");
marker = s->info.args.get("marker");
end_marker = s->info.args.get("end_marker");
max_keys = s->info.args.get("limit");
// non-standard
s->info.args.get_bool("allow_unordered", &allow_unordered, false);
delimiter = s->info.args.get("delimiter");
op_ret = parse_max_keys();
if (op_ret < 0) {
return op_ret;
}
// S3 behavior is to silently cap the max-keys.
// Swift behavior is to abort.
if (max > default_max)
return -ERR_PRECONDITION_FAILED;
string path_args;
if (s->info.args.exists("path")) { // should handle empty path
path_args = s->info.args.get("path");
if (!delimiter.empty() || !prefix.empty()) {
return -EINVAL;
}
prefix = path_args;
delimiter="/";
path = prefix;
if (path.size() && path[path.size() - 1] != '/')
path.append("/");
int len = prefix.size();
int delim_size = delimiter.size();
if (len >= delim_size) {
if (prefix.substr(len - delim_size).compare(delimiter) != 0)
prefix.append(delimiter);
}
}
return 0;
}
static void dump_container_metadata(req_state *,
const rgw::sal::Bucket*,
const RGWQuotaInfo&,
const RGWBucketWebsiteConf&);
void RGWListBucket_ObjStore_SWIFT::send_response()
{
vector<rgw_bucket_dir_entry>::iterator iter = objs.begin();
map<string, bool>::iterator pref_iter = common_prefixes.begin();
dump_start(s);
dump_container_metadata(s, s->bucket.get(), quota.bucket_quota,
s->bucket->get_info().website_conf);
s->formatter->open_array_section_with_attrs("container",
FormatterAttrs("name",
s->bucket->get_name().c_str(),
NULL));
while (iter != objs.end() || pref_iter != common_prefixes.end()) {
bool do_pref = false;
bool do_objs = false;
rgw_obj_key key;
if (iter != objs.end()) {
key = iter->key;
}
if (pref_iter == common_prefixes.end())
do_objs = true;
else if (iter == objs.end())
do_pref = true;
else if (!key.empty() && key.name.compare(pref_iter->first) == 0) {
do_objs = true;
++pref_iter;
} else if (!key.empty() && key.name.compare(pref_iter->first) <= 0)
do_objs = true;
else
do_pref = true;
if (do_objs && (allow_unordered || marker.empty() || marker < key)) {
if (key.name.compare(path) == 0)
goto next;
s->formatter->open_object_section("object");
s->formatter->dump_string("name", key.name);
s->formatter->dump_string("hash", iter->meta.etag);
s->formatter->dump_int("bytes", iter->meta.accounted_size);
if (!iter->meta.user_data.empty())
s->formatter->dump_string("user_custom_data", iter->meta.user_data);
string single_content_type = iter->meta.content_type;
if (iter->meta.content_type.size()) {
// content type might hold multiple values, just dump the last one
ssize_t pos = iter->meta.content_type.rfind(',');
if (pos > 0) {
++pos;
while (single_content_type[pos] == ' ')
++pos;
single_content_type = single_content_type.substr(pos);
}
s->formatter->dump_string("content_type", single_content_type);
}
dump_time(s, "last_modified", iter->meta.mtime);
s->formatter->close_section();
}
if (do_pref && (marker.empty() || pref_iter->first.compare(marker.name) > 0)) {
const string& name = pref_iter->first;
if (name.compare(delimiter) == 0)
goto next;
s->formatter->open_object_section_with_attrs("subdir", FormatterAttrs("name", name.c_str(), NULL));
/* swift is a bit inconsistent here */
switch (s->format) {
case RGWFormat::XML:
s->formatter->dump_string("name", name);
break;
default:
s->formatter->dump_string("subdir", name);
}
s->formatter->close_section();
}
next:
if (do_objs)
++iter;
else
++pref_iter;
}
s->formatter->close_section();
int64_t content_len = 0;
if (! op_ret) {
content_len = s->formatter->get_len();
if (content_len == 0) {
op_ret = STATUS_NO_CONTENT;
}
} else if (op_ret > 0) {
op_ret = 0;
}
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this, NULL, content_len);
if (op_ret < 0) {
return;
}
rgw_flush_formatter_and_reset(s, s->formatter);
} // RGWListBucket_ObjStore_SWIFT::send_response
static void dump_container_metadata(req_state *s,
const rgw::sal::Bucket* bucket,
const RGWQuotaInfo& quota,
const RGWBucketWebsiteConf& ws_conf)
{
/* Adding X-Timestamp to keep align with Swift API */
dump_header(s, "X-Timestamp", utime_t(s->bucket->get_info().creation_time));
dump_header(s, "X-Container-Object-Count", bucket->get_count());
dump_header(s, "X-Container-Bytes-Used", bucket->get_size());
dump_header(s, "X-Container-Bytes-Used-Actual", bucket->get_size_rounded());
if (rgw::sal::Object::empty(s->object.get())) {
auto swift_policy = \
static_cast<RGWAccessControlPolicy_SWIFT*>(s->bucket_acl.get());
std::string read_acl, write_acl;
swift_policy->to_str(read_acl, write_acl);
if (read_acl.size()) {
dump_header(s, "X-Container-Read", read_acl);
}
if (write_acl.size()) {
dump_header(s, "X-Container-Write", write_acl);
}
if (!s->bucket->get_placement_rule().name.empty()) {
dump_header(s, "X-Storage-Policy", s->bucket->get_placement_rule().name);
}
dump_header(s, "X-Storage-Class", s->bucket->get_placement_rule().get_storage_class());
/* Dump user-defined metadata items and generic attrs. */
const size_t PREFIX_LEN = sizeof(RGW_ATTR_META_PREFIX) - 1;
map<string, bufferlist>::iterator iter;
for (iter = s->bucket_attrs.lower_bound(RGW_ATTR_PREFIX);
iter != s->bucket_attrs.end();
++iter) {
const char *name = iter->first.c_str();
map<string, string>::const_iterator geniter = rgw_to_http_attrs.find(name);
if (geniter != rgw_to_http_attrs.end()) {
dump_header(s, geniter->second, iter->second);
} else if (strncmp(name, RGW_ATTR_META_PREFIX, PREFIX_LEN) == 0) {
dump_header_prefixed(s, "X-Container-Meta-",
camelcase_dash_http_attr(name + PREFIX_LEN),
iter->second);
}
}
}
/* Dump container versioning info. */
if (! s->bucket->get_info().swift_ver_location.empty()) {
dump_header(s, "X-Versions-Location",
url_encode(s->bucket->get_info().swift_ver_location));
}
/* Dump quota headers. */
if (quota.enabled) {
if (quota.max_size >= 0) {
dump_header(s, "X-Container-Meta-Quota-Bytes", quota.max_size);
}
if (quota.max_objects >= 0) {
dump_header(s, "X-Container-Meta-Quota-Count", quota.max_objects);
}
}
/* Dump Static Website headers. */
if (! ws_conf.index_doc_suffix.empty()) {
dump_header(s, "X-Container-Meta-Web-Index", ws_conf.index_doc_suffix);
}
if (! ws_conf.error_doc.empty()) {
dump_header(s, "X-Container-Meta-Web-Error", ws_conf.error_doc);
}
if (! ws_conf.subdir_marker.empty()) {
dump_header(s, "X-Container-Meta-Web-Directory-Type",
ws_conf.subdir_marker);
}
if (! ws_conf.listing_css_doc.empty()) {
dump_header(s, "X-Container-Meta-Web-Listings-CSS",
ws_conf.listing_css_doc);
}
if (ws_conf.listing_enabled) {
dump_header(s, "X-Container-Meta-Web-Listings", "true");
}
/* Dump bucket's modification time. Compliance with the Swift API really
* needs that. */
dump_last_modified(s, s->bucket_mtime);
}
void RGWStatAccount_ObjStore_SWIFT::execute(optional_yield y)
{
RGWStatAccount_ObjStore::execute(y);
op_ret = s->user->read_attrs(s, s->yield);
attrs = s->user->get_attrs();
}
void RGWStatAccount_ObjStore_SWIFT::send_response()
{
if (op_ret >= 0) {
op_ret = STATUS_NO_CONTENT;
dump_account_metadata(s,
global_stats,
policies_stats,
attrs,
s->user->get_info().quota.user_quota,
s->user->get_max_buckets(),
static_cast<RGWAccessControlPolicy_SWIFTAcct&>(*s->user_acl));
}
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, NULL, NULL, 0, true);
dump_start(s);
}
void RGWStatBucket_ObjStore_SWIFT::send_response()
{
if (op_ret >= 0) {
op_ret = STATUS_NO_CONTENT;
dump_container_metadata(s, bucket.get(), quota.bucket_quota,
s->bucket->get_info().website_conf);
}
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this, NULL, 0, true);
dump_start(s);
}
static int get_swift_container_settings(req_state * const s,
rgw::sal::Driver* const driver,
RGWAccessControlPolicy * const policy,
bool * const has_policy,
uint32_t * rw_mask,
RGWCORSConfiguration * const cors_config,
bool * const has_cors)
{
const char * const read_list = s->info.env->get("HTTP_X_CONTAINER_READ");
const char * const write_list = s->info.env->get("HTTP_X_CONTAINER_WRITE");
*has_policy = false;
if (read_list || write_list) {
RGWAccessControlPolicy_SWIFT swift_policy(s->cct);
const auto r = swift_policy.create(s, driver,
s->user->get_id(),
s->user->get_display_name(),
read_list,
write_list,
*rw_mask);
if (r < 0) {
return r;
}
*policy = swift_policy;
*has_policy = true;
}
*has_cors = false;
/*Check and update CORS configuration*/
const char *allow_origins = s->info.env->get("HTTP_X_CONTAINER_META_ACCESS_CONTROL_ALLOW_ORIGIN");
const char *allow_headers = s->info.env->get("HTTP_X_CONTAINER_META_ACCESS_CONTROL_ALLOW_HEADERS");
const char *expose_headers = s->info.env->get("HTTP_X_CONTAINER_META_ACCESS_CONTROL_EXPOSE_HEADERS");
const char *max_age = s->info.env->get("HTTP_X_CONTAINER_META_ACCESS_CONTROL_MAX_AGE");
if (allow_origins) {
RGWCORSConfiguration_SWIFT *swift_cors = new RGWCORSConfiguration_SWIFT;
int r = swift_cors->create_update(allow_origins, allow_headers, expose_headers, max_age);
if (r < 0) {
ldpp_dout(s, 0) << "Error creating/updating the cors configuration" << dendl;
delete swift_cors;
return r;
}
*has_cors = true;
*cors_config = *swift_cors;
cors_config->dump();
delete swift_cors;
}
return 0;
}
#define ACCT_REMOVE_ATTR_PREFIX "HTTP_X_REMOVE_ACCOUNT_META_"
#define ACCT_PUT_ATTR_PREFIX "HTTP_X_ACCOUNT_META_"
#define CONT_REMOVE_ATTR_PREFIX "HTTP_X_REMOVE_CONTAINER_META_"
#define CONT_PUT_ATTR_PREFIX "HTTP_X_CONTAINER_META_"
static void get_rmattrs_from_headers(const req_state * const s,
const char * const put_prefix,
const char * const del_prefix,
set<string>& rmattr_names)
{
const size_t put_prefix_len = strlen(put_prefix);
const size_t del_prefix_len = strlen(del_prefix);
for (const auto& kv : s->info.env->get_map()) {
size_t prefix_len = 0;
const char * const p = kv.first.c_str();
if (strncasecmp(p, del_prefix, del_prefix_len) == 0) {
/* Explicitly requested removal. */
prefix_len = del_prefix_len;
} else if ((strncasecmp(p, put_prefix, put_prefix_len) == 0)
&& kv.second.empty()) {
/* Removal requested by putting an empty value. */
prefix_len = put_prefix_len;
}
if (prefix_len > 0) {
string name(RGW_ATTR_META_PREFIX);
name.append(lowercase_dash_http_attr(p + prefix_len));
rmattr_names.insert(name);
}
}
}
static int get_swift_versioning_settings(
req_state * const s,
boost::optional<std::string>& swift_ver_location)
{
/* Removing the Swift's versions location has lower priority than setting
* a new one. That's the reason why we're handling it first. */
const std::string vlocdel =
s->info.env->get("HTTP_X_REMOVE_VERSIONS_LOCATION", "");
if (vlocdel.size()) {
swift_ver_location = boost::in_place(std::string());
}
if (s->info.env->exists("HTTP_X_VERSIONS_LOCATION")) {
/* If the Swift's versioning is globally disabled but someone wants to
* enable it for a given container, new version of Swift will generate
* the precondition failed error. */
if (! s->cct->_conf->rgw_swift_versioning_enabled) {
return -ERR_PRECONDITION_FAILED;
}
swift_ver_location = s->info.env->get("HTTP_X_VERSIONS_LOCATION", "");
}
return 0;
}
int RGWCreateBucket_ObjStore_SWIFT::get_params(optional_yield y)
{
bool has_policy;
uint32_t policy_rw_mask = 0;
int r = get_swift_container_settings(s, driver, &policy, &has_policy,
&policy_rw_mask, &cors_config, &has_cors);
if (r < 0) {
return r;
}
if (!has_policy) {
policy.create_default(s->user->get_id(), s->user->get_display_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);
return get_swift_versioning_settings(s, swift_ver_location);
}
static inline int handle_metadata_errors(req_state* const s, const int op_ret)
{
if (op_ret == -EFBIG) {
/* Handle the custom error message of exceeding maximum custom attribute
* (stored as xattr) size. */
const auto error_message = boost::str(
boost::format("Metadata value longer than %lld")
% s->cct->_conf.get_val<Option::size_t>("rgw_max_attr_size"));
set_req_state_err(s, EINVAL, error_message);
return -EINVAL;
} else if (op_ret == -E2BIG) {
const auto error_message = boost::str(
boost::format("Too many metadata items; max %lld")
% s->cct->_conf.get_val<uint64_t>("rgw_max_attrs_num_in_req"));
set_req_state_err(s, EINVAL, error_message);
return -EINVAL;
}
return op_ret;
}
void RGWCreateBucket_ObjStore_SWIFT::send_response()
{
const auto meta_ret = handle_metadata_errors(s, op_ret);
if (meta_ret != op_ret) {
op_ret = meta_ret;
} else {
if (!op_ret) {
op_ret = STATUS_CREATED;
} else if (op_ret == -ERR_BUCKET_EXISTS) {
op_ret = STATUS_ACCEPTED;
}
set_req_state_err(s, op_ret);
}
dump_errno(s);
/* Propose ending HTTP header with 0 Content-Length header. */
end_header(s, NULL, NULL, 0);
rgw_flush_formatter_and_reset(s, s->formatter);
}
void RGWDeleteBucket_ObjStore_SWIFT::send_response()
{
int r = op_ret;
if (!r)
r = STATUS_NO_CONTENT;
set_req_state_err(s, r);
dump_errno(s);
end_header(s, this, NULL, 0);
rgw_flush_formatter_and_reset(s, s->formatter);
}
static int get_delete_at_param(req_state *s, boost::optional<real_time> &delete_at)
{
/* Handle Swift object expiration. */
real_time delat_proposal;
string x_delete = s->info.env->get("HTTP_X_DELETE_AFTER", "");
if (x_delete.empty()) {
x_delete = s->info.env->get("HTTP_X_DELETE_AT", "");
} else {
/* X-Delete-After HTTP is present. It means we need add its value
* to the current time. */
delat_proposal = real_clock::now();
}
if (x_delete.empty()) {
delete_at = boost::none;
if (s->info.env->exists("HTTP_X_REMOVE_DELETE_AT")) {
delete_at = boost::in_place(real_time());
}
return 0;
}
string err;
long ts = strict_strtoll(x_delete.c_str(), 10, &err);
if (!err.empty()) {
return -EINVAL;
}
delat_proposal += make_timespan(ts);
if (delat_proposal < real_clock::now()) {
return -EINVAL;
}
delete_at = delat_proposal;
return 0;
}
int RGWPutObj_ObjStore_SWIFT::verify_permission(optional_yield y)
{
op_ret = RGWPutObj_ObjStore::verify_permission(y);
/* We have to differentiate error codes depending on whether user is
* anonymous (401 Unauthorized) or he doesn't have necessary permissions
* (403 Forbidden). */
if (s->auth.identity->is_anonymous() && op_ret == -EACCES) {
return -EPERM;
} else {
return op_ret;
}
}
int RGWPutObj_ObjStore_SWIFT::update_slo_segment_size(rgw_slo_entry& entry) {
int r = 0;
const string& path = entry.path;
/* If the path starts with slashes, strip them all. */
const size_t pos_init = path.find_first_not_of('/');
if (pos_init == string::npos) {
return -EINVAL;
}
const size_t pos_sep = path.find('/', pos_init);
if (pos_sep == string::npos) {
return -EINVAL;
}
string bucket_name = path.substr(pos_init, pos_sep - pos_init);
string obj_name = path.substr(pos_sep + 1);
std::unique_ptr<rgw::sal::Bucket> bucket;
if (bucket_name.compare(s->bucket->get_name()) != 0) {
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;
return r;
}
} else {
bucket = s->bucket->clone();
}
/* fetch the stored size of the seg (or error if not valid) */
std::unique_ptr<rgw::sal::Object> slo_seg = bucket->get_object(rgw_obj_key(obj_name));
/* no prefetch */
slo_seg->set_atomic();
bool compressed;
RGWCompressionInfo cs_info;
uint64_t size_bytes{0};
r = slo_seg->get_obj_attrs(s->yield, s);
if (r < 0) {
return r;
}
size_bytes = slo_seg->get_obj_size();
r = rgw_compression_info_from_attrset(slo_seg->get_attrs(), compressed, cs_info);
if (r < 0) {
return -EIO;
}
if (compressed) {
size_bytes = cs_info.orig_size;
}
/* "When the PUT operation sees the multipart-manifest=put query
* parameter, it reads the request body and verifies that each
* segment object exists and that the sizes and ETags match. If
* there is a mismatch, the PUT operation fails."
*/
if (entry.size_bytes &&
(entry.size_bytes != size_bytes)) {
return -EINVAL;
}
entry.size_bytes = size_bytes;
return 0;
} /* RGWPutObj_ObjStore_SWIFT::update_slo_segment_sizes */
int RGWPutObj_ObjStore_SWIFT::get_params(optional_yield y)
{
if (s->has_bad_meta) {
return -EINVAL;
}
if (!s->length) {
const char *encoding = s->info.env->get("HTTP_TRANSFER_ENCODING");
if (!encoding || strcmp(encoding, "chunked") != 0) {
ldpp_dout(this, 20) << "neither length nor chunked encoding" << dendl;
return -ERR_LENGTH_REQUIRED;
}
chunked_upload = true;
}
supplied_etag = s->info.env->get("HTTP_ETAG");
if (!s->generic_attrs.count(RGW_ATTR_CONTENT_TYPE)) {
ldpp_dout(this, 5) << "content type wasn't provided, trying to guess" << dendl;
const char *suffix = strrchr(s->object->get_name().c_str(), '.');
if (suffix) {
suffix++;
if (*suffix) {
string suffix_str(suffix);
const char *mime = rgw_find_mime_by_ext(suffix_str);
if (mime) {
s->generic_attrs[RGW_ATTR_CONTENT_TYPE] = mime;
}
}
}
}
policy.create_default(s->user->get_id(), s->user->get_display_name());
int r = get_delete_at_param(s, delete_at);
if (r < 0) {
ldpp_dout(this, 5) << "ERROR: failed to get Delete-At param" << dendl;
return r;
}
if (!s->cct->_conf->rgw_swift_custom_header.empty()) {
string custom_header = s->cct->_conf->rgw_swift_custom_header;
auto data = s->info.env->get_optional(custom_header);
if (data) {
user_data = *data;
}
}
dlo_manifest = s->info.env->get("HTTP_X_OBJECT_MANIFEST");
bool exists;
string multipart_manifest = s->info.args.get("multipart-manifest", &exists);
if (exists) {
if (multipart_manifest != "put") {
ldpp_dout(this, 5) << "invalid multipart-manifest http param: " << multipart_manifest << dendl;
return -EINVAL;
}
#define MAX_SLO_ENTRY_SIZE (1024 + 128) // 1024 - max obj name, 128 - enough extra for other info
uint64_t max_len = s->cct->_conf->rgw_max_slo_entries * MAX_SLO_ENTRY_SIZE;
slo_info = new RGWSLOInfo;
int r = 0;
std::tie(r, slo_info->raw_data) = rgw_rest_get_json_input_keep_data(s->cct, s, slo_info->entries, max_len);
if (r < 0) {
ldpp_dout(this, 5) << "failed to read input for slo r=" << r << dendl;
return r;
}
if ((int64_t)slo_info->entries.size() > s->cct->_conf->rgw_max_slo_entries) {
ldpp_dout(this, 5) << "too many entries in slo request: " << slo_info->entries.size() << dendl;
return -EINVAL;
}
MD5 etag_sum;
// Allow use of MD5 digest in FIPS mode for non-cryptographic purposes
etag_sum.SetFlags(EVP_MD_CTX_FLAG_NON_FIPS_ALLOW);
uint64_t total_size = 0;
for (auto& entry : slo_info->entries) {
etag_sum.Update((const unsigned char *)entry.etag.c_str(),
entry.etag.length());
/* if size_bytes == 0, it should be replaced with the
* real segment size (which could be 0); this follows from the
* fact that Swift requires all segments to exist, but permits
* the size_bytes element to be omitted from the SLO manifest, see
* https://docs.openstack.org/swift/latest/api/large_objects.html
*/
r = update_slo_segment_size(entry);
if (r < 0) {
return r;
}
total_size += entry.size_bytes;
ldpp_dout(this, 20) << "slo_part: " << entry.path
<< " size=" << entry.size_bytes
<< " etag=" << entry.etag
<< dendl;
}
complete_etag(etag_sum, &lo_etag);
slo_info->total_size = total_size;
ofs = slo_info->raw_data.length();
}
return RGWPutObj_ObjStore::get_params(y);
}
void RGWPutObj_ObjStore_SWIFT::send_response()
{
const auto meta_ret = handle_metadata_errors(s, op_ret);
if (meta_ret) {
op_ret = meta_ret;
} else {
if (!op_ret) {
op_ret = STATUS_CREATED;
}
set_req_state_err(s, op_ret);
}
if (! lo_etag.empty()) {
/* Static Large Object of Swift API has two etags represented by
* following members:
* - etag - for the manifest itself (it will be stored in xattrs),
* - lo_etag - for the content composited from SLO's segments.
* The value is calculated basing on segments' etags.
* In response for PUT request we have to expose the second one.
* The first one may be obtained by GET with "multipart-manifest=get"
* in query string on a given SLO. */
dump_etag(s, lo_etag, true /* quoted */);
} else {
dump_etag(s, etag);
}
dump_last_modified(s, mtime);
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this);
rgw_flush_formatter_and_reset(s, s->formatter);
}
static int get_swift_account_settings(req_state * const s,
rgw::sal::Driver* const driver,
RGWAccessControlPolicy_SWIFTAcct* const policy,
bool * const has_policy)
{
*has_policy = false;
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, driver,
s->user->get_id(),
s->user->get_display_name(),
string(acl_attr));
if (r != true) {
return -EINVAL;
}
*policy = swift_acct_policy;
*has_policy = true;
}
return 0;
}
int RGWPutMetadataAccount_ObjStore_SWIFT::get_params(optional_yield y)
{
if (s->has_bad_meta) {
return -EINVAL;
}
int ret = get_swift_account_settings(s,
driver,
// FIXME: we need to carry unique_ptr in generic class
// and allocate appropriate ACL class in the ctor
static_cast<RGWAccessControlPolicy_SWIFTAcct *>(&policy),
&has_policy);
if (ret < 0) {
return ret;
}
get_rmattrs_from_headers(s, ACCT_PUT_ATTR_PREFIX, ACCT_REMOVE_ATTR_PREFIX,
rmattr_names);
return 0;
}
void RGWPutMetadataAccount_ObjStore_SWIFT::send_response()
{
const auto meta_ret = handle_metadata_errors(s, op_ret);
if (meta_ret != op_ret) {
op_ret = meta_ret;
} else {
if (!op_ret) {
op_ret = STATUS_NO_CONTENT;
}
set_req_state_err(s, op_ret);
}
dump_errno(s);
end_header(s, this);
rgw_flush_formatter_and_reset(s, s->formatter);
}
int RGWPutMetadataBucket_ObjStore_SWIFT::get_params(optional_yield y)
{
if (s->has_bad_meta) {
return -EINVAL;
}
int r = get_swift_container_settings(s, driver, &policy, &has_policy,
&policy_rw_mask, &cors_config, &has_cors);
if (r < 0) {
return r;
}
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);
return get_swift_versioning_settings(s, swift_ver_location);
}
void RGWPutMetadataBucket_ObjStore_SWIFT::send_response()
{
const auto meta_ret = handle_metadata_errors(s, op_ret);
if (meta_ret != op_ret) {
op_ret = meta_ret;
} else {
if (!op_ret && (op_ret != -EINVAL)) {
op_ret = STATUS_NO_CONTENT;
}
set_req_state_err(s, op_ret);
}
dump_errno(s);
end_header(s, this);
rgw_flush_formatter_and_reset(s, s->formatter);
}
int RGWPutMetadataObject_ObjStore_SWIFT::get_params(optional_yield y)
{
if (s->has_bad_meta) {
return -EINVAL;
}
/* Handle Swift object expiration. */
int r = get_delete_at_param(s, delete_at);
if (r < 0) {
ldpp_dout(this, 5) << "ERROR: failed to get Delete-At param" << dendl;
return r;
}
dlo_manifest = s->info.env->get("HTTP_X_OBJECT_MANIFEST");
return 0;
}
void RGWPutMetadataObject_ObjStore_SWIFT::send_response()
{
const auto meta_ret = handle_metadata_errors(s, op_ret);
if (meta_ret != op_ret) {
op_ret = meta_ret;
} else {
if (!op_ret) {
op_ret = STATUS_ACCEPTED;
}
set_req_state_err(s, op_ret);
}
if (!s->is_err()) {
dump_content_length(s, 0);
}
dump_errno(s);
end_header(s, this);
rgw_flush_formatter_and_reset(s, s->formatter);
}
static void bulkdelete_respond(const unsigned num_deleted,
const unsigned int num_unfound,
const std::list<RGWBulkDelete::fail_desc_t>& failures,
const int prot_flags, /* in */
ceph::Formatter& formatter) /* out */
{
formatter.open_object_section("delete");
string resp_status;
string resp_body;
if (!failures.empty()) {
int reason = ERR_INVALID_REQUEST;
for (const auto& fail_desc : failures) {
if (-ENOENT != fail_desc.err && -EACCES != fail_desc.err) {
reason = fail_desc.err;
}
}
rgw_err err;
set_req_state_err(err, reason, prot_flags);
dump_errno(err, resp_status);
} else if (0 == num_deleted && 0 == num_unfound) {
/* 400 Bad Request */
dump_errno(400, resp_status);
resp_body = "Invalid bulk delete.";
} else {
/* 200 OK */
dump_errno(200, resp_status);
}
encode_json("Number Deleted", num_deleted, &formatter);
encode_json("Number Not Found", num_unfound, &formatter);
encode_json("Response Body", resp_body, &formatter);
encode_json("Response Status", resp_status, &formatter);
formatter.open_array_section("Errors");
for (const auto& fail_desc : failures) {
formatter.open_array_section("object");
stringstream ss_name;
ss_name << fail_desc.path;
encode_json("Name", ss_name.str(), &formatter);
rgw_err err;
set_req_state_err(err, fail_desc.err, prot_flags);
string status;
dump_errno(err, status);
encode_json("Status", status, &formatter);
formatter.close_section();
}
formatter.close_section();
formatter.close_section();
}
int RGWDeleteObj_ObjStore_SWIFT::verify_permission(optional_yield y)
{
op_ret = RGWDeleteObj_ObjStore::verify_permission(y);
/* We have to differentiate error codes depending on whether user is
* anonymous (401 Unauthorized) or he doesn't have necessary permissions
* (403 Forbidden). */
if (s->auth.identity->is_anonymous() && op_ret == -EACCES) {
return -EPERM;
} else {
return op_ret;
}
}
int RGWDeleteObj_ObjStore_SWIFT::get_params(optional_yield y)
{
const string& mm = s->info.args.get("multipart-manifest");
multipart_delete = (mm.compare("delete") == 0);
return RGWDeleteObj_ObjStore::get_params(y);
}
void RGWDeleteObj_ObjStore_SWIFT::send_response()
{
int r = op_ret;
if (multipart_delete) {
r = 0;
} else if(!r) {
r = STATUS_NO_CONTENT;
}
set_req_state_err(s, r);
dump_errno(s);
if (multipart_delete) {
end_header(s, this /* RGWOp */, nullptr /* contype */,
CHUNKED_TRANSFER_ENCODING);
if (deleter) {
bulkdelete_respond(deleter->get_num_deleted(),
deleter->get_num_unfound(),
deleter->get_failures(),
s->prot_flags,
*s->formatter);
} else if (-ENOENT == op_ret) {
bulkdelete_respond(0, 1, {}, s->prot_flags, *s->formatter);
} else {
RGWBulkDelete::acct_path_t path;
path.bucket_name = s->bucket_name;
path.obj_key = s->object->get_key();
RGWBulkDelete::fail_desc_t fail_desc;
fail_desc.err = op_ret;
fail_desc.path = path;
bulkdelete_respond(0, 0, { fail_desc }, s->prot_flags, *s->formatter);
}
} else {
end_header(s, this);
}
rgw_flush_formatter_and_reset(s, s->formatter);
}
static void get_contype_from_attrs(map<string, bufferlist>& attrs,
string& content_type)
{
map<string, bufferlist>::iterator iter = attrs.find(RGW_ATTR_CONTENT_TYPE);
if (iter != attrs.end()) {
content_type = rgw_bl_str(iter->second);
}
}
static void dump_object_metadata(const DoutPrefixProvider* dpp, req_state * const s,
const map<string, bufferlist>& attrs)
{
map<string, string> response_attrs;
for (auto kv : attrs) {
const char * name = kv.first.c_str();
const auto aiter = rgw_to_http_attrs.find(name);
if (aiter != std::end(rgw_to_http_attrs)) {
response_attrs[aiter->second] = rgw_bl_str(kv.second);
} else if (strcmp(name, RGW_ATTR_SLO_UINDICATOR) == 0) {
// this attr has an extra length prefix from encode() in prior versions
dump_header(s, "X-Object-Meta-Static-Large-Object", "True");
} else if (strncmp(name, RGW_ATTR_META_PREFIX,
sizeof(RGW_ATTR_META_PREFIX)-1) == 0) {
name += sizeof(RGW_ATTR_META_PREFIX) - 1;
dump_header_prefixed(s, "X-Object-Meta-",
camelcase_dash_http_attr(name), kv.second);
}
}
/* Handle override and fallback for Content-Disposition HTTP header.
* At the moment this will be used only by TempURL of the Swift API. */
const auto cditer = rgw_to_http_attrs.find(RGW_ATTR_CONTENT_DISP);
if (cditer != std::end(rgw_to_http_attrs)) {
const auto& name = cditer->second;
if (!s->content_disp.override.empty()) {
response_attrs[name] = s->content_disp.override;
} else if (!s->content_disp.fallback.empty()
&& response_attrs.find(name) == std::end(response_attrs)) {
response_attrs[name] = s->content_disp.fallback;
}
}
for (const auto& kv : response_attrs) {
dump_header(s, kv.first, kv.second);
}
const auto iter = attrs.find(RGW_ATTR_DELETE_AT);
if (iter != std::end(attrs)) {
utime_t delete_at;
try {
decode(delete_at, iter->second);
if (!delete_at.is_zero()) {
dump_header(s, "X-Delete-At", delete_at.sec());
}
} catch (buffer::error& err) {
ldpp_dout(dpp, 0) << "ERROR: cannot decode object's " RGW_ATTR_DELETE_AT
" attr, ignoring"
<< dendl;
}
}
}
int RGWCopyObj_ObjStore_SWIFT::init_dest_policy()
{
dest_policy.create_default(s->user->get_id(), s->user->get_display_name());
return 0;
}
int RGWCopyObj_ObjStore_SWIFT::get_params(optional_yield y)
{
if_mod = s->info.env->get("HTTP_IF_MODIFIED_SINCE");
if_unmod = s->info.env->get("HTTP_IF_UNMODIFIED_SINCE");
if_match = s->info.env->get("HTTP_COPY_IF_MATCH");
if_nomatch = s->info.env->get("HTTP_COPY_IF_NONE_MATCH");
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;
} else {
attrs_mod = rgw::sal::ATTRSMOD_MERGE;
}
int r = get_delete_at_param(s, delete_at);
if (r < 0) {
ldpp_dout(this, 5) << "ERROR: failed to get Delete-At param" << dendl;
return r;
}
return 0;
}
void RGWCopyObj_ObjStore_SWIFT::send_partial_response(off_t ofs)
{
if (! sent_header) {
if (! op_ret)
op_ret = STATUS_CREATED;
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this);
/* Send progress information. Note that this diverge from the original swift
* spec. We do this in order to keep connection alive.
*/
if (op_ret == 0) {
s->formatter->open_array_section("progress");
}
sent_header = true;
} else {
s->formatter->dump_int("ofs", (uint64_t)ofs);
}
rgw_flush_formatter(s, s->formatter);
}
void RGWCopyObj_ObjStore_SWIFT::dump_copy_info()
{
/* Dump X-Copied-From. */
dump_header(s, "X-Copied-From", url_encode(src_bucket->get_name()) +
"/" + url_encode(s->src_object->get_name()));
/* Dump X-Copied-From-Account. */
/* XXX tenant */
dump_header(s, "X-Copied-From-Account", url_encode(s->user->get_id().id));
/* Dump X-Copied-From-Last-Modified. */
dump_time_header(s, "X-Copied-From-Last-Modified", src_mtime);
}
void RGWCopyObj_ObjStore_SWIFT::send_response()
{
if (! sent_header) {
string content_type;
if (! op_ret)
op_ret = STATUS_CREATED;
set_req_state_err(s, op_ret);
dump_errno(s);
dump_etag(s, etag);
dump_last_modified(s, mtime);
dump_copy_info();
get_contype_from_attrs(attrs, content_type);
dump_object_metadata(this, s, attrs);
end_header(s, this, !content_type.empty() ? content_type.c_str()
: "binary/octet-stream");
} else {
s->formatter->close_section();
rgw_flush_formatter(s, s->formatter);
}
}
int RGWGetObj_ObjStore_SWIFT::verify_permission(optional_yield y)
{
op_ret = RGWGetObj_ObjStore::verify_permission(y);
/* We have to differentiate error codes depending on whether user is
* anonymous (401 Unauthorized) or he doesn't have necessary permissions
* (403 Forbidden). */
if (s->auth.identity->is_anonymous() && op_ret == -EACCES) {
return -EPERM;
} else {
return op_ret;
}
}
int RGWGetObj_ObjStore_SWIFT::get_params(optional_yield y)
{
const string& mm = s->info.args.get("multipart-manifest");
skip_manifest = (mm.compare("get") == 0);
return RGWGetObj_ObjStore::get_params(y);
}
int RGWGetObj_ObjStore_SWIFT::send_response_data_error(optional_yield y)
{
std::string error_content;
op_ret = error_handler(op_ret, &error_content, y);
if (! op_ret) {
/* The error handler has taken care of the error. */
return 0;
}
bufferlist error_bl;
error_bl.append(error_content);
return send_response_data(error_bl, 0, error_bl.length());
}
int RGWGetObj_ObjStore_SWIFT::send_response_data(bufferlist& bl,
const off_t bl_ofs,
const off_t bl_len)
{
string content_type;
if (sent_header) {
goto send_data;
}
if (custom_http_ret) {
set_req_state_err(s, 0);
dump_errno(s, custom_http_ret);
} else {
set_req_state_err(s, (partial_content && !op_ret) ? STATUS_PARTIAL_CONTENT
: op_ret);
dump_errno(s);
if (s->is_err()) {
end_header(s, NULL);
return 0;
}
}
if (range_str) {
dump_range(s, ofs, end, s->obj_size);
}
if (s->is_err()) {
end_header(s, NULL);
return 0;
}
dump_content_length(s, total_len);
dump_last_modified(s, lastmod);
dump_header(s, "X-Timestamp", utime_t(lastmod));
if (is_slo) {
dump_header(s, "X-Static-Large-Object", "True");
}
if (! op_ret) {
if (! lo_etag.empty()) {
dump_etag(s, lo_etag, true /* quoted */);
} else {
auto iter = attrs.find(RGW_ATTR_ETAG);
if (iter != attrs.end()) {
dump_etag(s, iter->second.to_str());
}
}
get_contype_from_attrs(attrs, content_type);
dump_object_metadata(this, s, attrs);
}
end_header(s, this, !content_type.empty() ? content_type.c_str()
: "binary/octet-stream");
sent_header = true;
send_data:
if (get_data && !op_ret) {
const auto r = dump_body(s, bl.c_str() + bl_ofs, bl_len);
if (r < 0) {
return r;
}
}
rgw_flush_formatter_and_reset(s, s->formatter);
return 0;
}
void RGWOptionsCORS_ObjStore_SWIFT::send_response()
{
string hdrs, exp_hdrs;
uint32_t max_age = CORS_MAX_AGE_INVALID;
/*EACCES means, there is no CORS registered yet for the bucket
*ENOENT means, there is no match of the Origin in the list of CORSRule
*/
if (op_ret == -ENOENT)
op_ret = -EACCES;
if (op_ret < 0) {
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, NULL);
return;
}
get_response_params(hdrs, exp_hdrs, &max_age);
dump_errno(s);
dump_access_control(s, origin, req_meth, hdrs.c_str(), exp_hdrs.c_str(),
max_age);
end_header(s, NULL);
}
int RGWBulkDelete_ObjStore_SWIFT::get_data(
list<RGWBulkDelete::acct_path_t>& items, bool * const is_truncated)
{
constexpr size_t MAX_LINE_SIZE = 2048;
RGWClientIOStreamBuf ciosb(static_cast<RGWRestfulIO&>(*(s->cio)),
size_t(s->cct->_conf->rgw_max_chunk_size));
istream cioin(&ciosb);
char buf[MAX_LINE_SIZE];
while (cioin.getline(buf, sizeof(buf))) {
string path_str(buf);
ldpp_dout(this, 20) << "extracted Bulk Delete entry: " << path_str << dendl;
RGWBulkDelete::acct_path_t path;
/* We need to skip all slashes at the beginning in order to preserve
* compliance with Swift. */
const size_t start_pos = path_str.find_first_not_of('/');
if (string::npos != start_pos) {
/* Seperator is the first slash after the leading ones. */
const size_t sep_pos = path_str.find('/', start_pos);
if (string::npos != sep_pos) {
path.bucket_name = url_decode(path_str.substr(start_pos,
sep_pos - start_pos));
path.obj_key = url_decode(path_str.substr(sep_pos + 1));
} else {
/* It's guaranteed here that bucket name is at least one character
* long and is different than slash. */
path.bucket_name = url_decode(path_str.substr(start_pos));
}
items.push_back(path);
}
if (items.size() == MAX_CHUNK_ENTRIES) {
*is_truncated = true;
return 0;
}
}
*is_truncated = false;
return 0;
}
void RGWBulkDelete_ObjStore_SWIFT::send_response()
{
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this /* RGWOp */, nullptr /* contype */,
CHUNKED_TRANSFER_ENCODING);
bulkdelete_respond(deleter->get_num_deleted(),
deleter->get_num_unfound(),
deleter->get_failures(),
s->prot_flags,
*s->formatter);
rgw_flush_formatter_and_reset(s, s->formatter);
}
std::unique_ptr<RGWBulkUploadOp::StreamGetter>
RGWBulkUploadOp_ObjStore_SWIFT::create_stream()
{
class SwiftStreamGetter : public StreamGetter {
const DoutPrefixProvider* dpp;
const size_t conlen;
size_t curpos;
req_state* const s;
public:
SwiftStreamGetter(const DoutPrefixProvider* dpp, req_state* const s, const size_t conlen)
: dpp(dpp),
conlen(conlen),
curpos(0),
s(s) {
}
ssize_t get_at_most(size_t want, ceph::bufferlist& dst) override {
/* maximum requested by a caller */
/* data provided by client */
/* RadosGW's limit. */
const size_t max_chunk_size = \
static_cast<size_t>(s->cct->_conf->rgw_max_chunk_size);
const size_t max_to_read = std::min({ want, conlen - curpos, max_chunk_size });
ldpp_dout(dpp, 20) << "bulk_upload: get_at_most max_to_read="
<< max_to_read
<< ", dst.c_str()=" << reinterpret_cast<intptr_t>(dst.c_str()) << dendl;
bufferptr bp(max_to_read);
const auto read_len = recv_body(s, bp.c_str(), max_to_read);
dst.append(bp, 0, read_len);
//const auto read_len = recv_body(s, dst.c_str(), max_to_read);
if (read_len < 0) {
return read_len;
}
curpos += read_len;
return curpos > s->cct->_conf->rgw_max_put_size ? -ERR_TOO_LARGE
: read_len;
}
ssize_t get_exactly(size_t want, ceph::bufferlist& dst) override {
ldpp_dout(dpp, 20) << "bulk_upload: get_exactly want=" << want << dendl;
/* FIXME: do this in a loop. */
const auto ret = get_at_most(want, dst);
ldpp_dout(dpp, 20) << "bulk_upload: get_exactly ret=" << ret << dendl;
if (ret < 0) {
return ret;
} else if (static_cast<size_t>(ret) != want) {
return -EINVAL;
} else {
return want;
}
}
};
if (! s->length) {
op_ret = -EINVAL;
return nullptr;
} else {
ldpp_dout(this, 20) << "bulk upload: create_stream for length="
<< s->length << dendl;
const size_t conlen = atoll(s->length);
return std::unique_ptr<SwiftStreamGetter>(new SwiftStreamGetter(this, s, conlen));
}
}
void RGWBulkUploadOp_ObjStore_SWIFT::send_response()
{
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this /* RGWOp */, nullptr /* contype */,
CHUNKED_TRANSFER_ENCODING);
rgw_flush_formatter_and_reset(s, s->formatter);
s->formatter->open_object_section("delete");
std::string resp_status;
std::string resp_body;
if (! failures.empty()) {
rgw_err err;
const auto last_err = { failures.back().err };
if (boost::algorithm::contains(last_err, terminal_errors)) {
/* The terminal errors are affecting the status of the whole upload. */
set_req_state_err(err, failures.back().err, s->prot_flags);
} else {
set_req_state_err(err, ERR_INVALID_REQUEST, s->prot_flags);
}
dump_errno(err, resp_status);
} else if (0 == num_created && failures.empty()) {
/* Nothing created, nothing failed. This means the archive contained no
* entity we could understand (regular file or directory). We need to
* send 400 Bad Request to an HTTP client in the internal status field. */
dump_errno(400, resp_status);
resp_body = "Invalid Tar File: No Valid Files";
} else {
/* 200 OK */
dump_errno(201, resp_status);
}
encode_json("Number Files Created", num_created, s->formatter);
encode_json("Response Body", resp_body, s->formatter);
encode_json("Response Status", resp_status, s->formatter);
s->formatter->open_array_section("Errors");
for (const auto& fail_desc : failures) {
s->formatter->open_array_section("object");
encode_json("Name", fail_desc.path, s->formatter);
rgw_err err;
set_req_state_err(err, fail_desc.err, s->prot_flags);
std::string status;
dump_errno(err, status);
encode_json("Status", status, s->formatter);
s->formatter->close_section();
}
s->formatter->close_section();
s->formatter->close_section();
rgw_flush_formatter_and_reset(s, s->formatter);
}
void RGWGetCrossDomainPolicy_ObjStore_SWIFT::send_response()
{
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this, "application/xml");
std::stringstream ss;
ss << R"(<?xml version="1.0"?>)" << "\n"
<< R"(<!DOCTYPE cross-domain-policy SYSTEM )"
<< R"("http://www.adobe.com/xml/dtds/cross-domain-policy.dtd" >)" << "\n"
<< R"(<cross-domain-policy>)" << "\n"
<< g_conf()->rgw_cross_domain_policy << "\n"
<< R"(</cross-domain-policy>)";
dump_body(s, ss.str());
}
void RGWGetHealthCheck_ObjStore_SWIFT::send_response()
{
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this, "application/xml");
if (op_ret) {
static constexpr char DISABLED[] = "DISABLED BY FILE";
dump_body(s, DISABLED, strlen(DISABLED));
}
}
const vector<pair<string, RGWInfo_ObjStore_SWIFT::info>> RGWInfo_ObjStore_SWIFT::swift_info =
{
{"bulk_delete", {false, nullptr}},
{"container_quotas", {false, nullptr}},
{"swift", {false, RGWInfo_ObjStore_SWIFT::list_swift_data}},
{"tempurl", { false, RGWInfo_ObjStore_SWIFT::list_tempurl_data}},
{"slo", {false, RGWInfo_ObjStore_SWIFT::list_slo_data}},
{"account_quotas", {false, nullptr}},
{"staticweb", {false, nullptr}},
{"tempauth", {false, RGWInfo_ObjStore_SWIFT::list_tempauth_data}},
};
void RGWInfo_ObjStore_SWIFT::execute(optional_yield y)
{
bool is_admin_info_enabled = false;
const string& swiftinfo_sig = s->info.args.get("swiftinfo_sig");
const string& swiftinfo_expires = s->info.args.get("swiftinfo_expires");
if (!swiftinfo_sig.empty() &&
!swiftinfo_expires.empty() &&
!is_expired(swiftinfo_expires, this)) {
is_admin_info_enabled = true;
}
s->formatter->open_object_section("info");
for (const auto& pair : swift_info) {
if(!is_admin_info_enabled && pair.second.is_admin_info)
continue;
if (!pair.second.list_data) {
s->formatter->open_object_section((pair.first).c_str());
s->formatter->close_section();
}
else {
pair.second.list_data(*(s->formatter), s->cct->_conf, driver);
}
}
s->formatter->close_section();
}
void RGWInfo_ObjStore_SWIFT::send_response()
{
if (op_ret < 0) {
op_ret = STATUS_NO_CONTENT;
}
set_req_state_err(s, op_ret);
dump_errno(s);
end_header(s, this);
rgw_flush_formatter_and_reset(s, s->formatter);
}
void RGWInfo_ObjStore_SWIFT::list_swift_data(Formatter& formatter,
const ConfigProxy& config,
rgw::sal::Driver* driver)
{
formatter.open_object_section("swift");
formatter.dump_int("max_file_size", config->rgw_max_put_size);
formatter.dump_int("container_listing_limit", RGW_LIST_BUCKETS_LIMIT_MAX);
string ceph_version(CEPH_GIT_NICE_VER);
formatter.dump_string("version", ceph_version);
const size_t max_attr_name_len = \
g_conf().get_val<Option::size_t>("rgw_max_attr_name_len");
if (max_attr_name_len) {
const size_t meta_name_limit = \
max_attr_name_len - strlen(RGW_ATTR_PREFIX RGW_AMZ_META_PREFIX);
formatter.dump_int("max_meta_name_length", meta_name_limit);
}
const size_t meta_value_limit = g_conf().get_val<Option::size_t>("rgw_max_attr_size");
if (meta_value_limit) {
formatter.dump_int("max_meta_value_length", meta_value_limit);
}
const size_t meta_num_limit = \
g_conf().get_val<uint64_t>("rgw_max_attrs_num_in_req");
if (meta_num_limit) {
formatter.dump_int("max_meta_count", meta_num_limit);
}
formatter.open_array_section("policies");
const rgw::sal::ZoneGroup& zonegroup = driver->get_zone()->get_zonegroup();
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();
formatter.dump_int("max_object_name_size", RGWHandler_REST::MAX_OBJ_NAME_LEN);
formatter.dump_bool("strict_cors_mode", true);
formatter.dump_int("max_container_name_length", RGWHandler_REST::MAX_BUCKET_NAME_LEN);
formatter.close_section();
}
void RGWInfo_ObjStore_SWIFT::list_tempauth_data(Formatter& formatter,
const ConfigProxy& config,
rgw::sal::Driver* driver)
{
formatter.open_object_section("tempauth");
formatter.dump_bool("account_acls", true);
formatter.close_section();
}
void RGWInfo_ObjStore_SWIFT::list_tempurl_data(Formatter& formatter,
const ConfigProxy& config,
rgw::sal::Driver* driver)
{
formatter.open_object_section("tempurl");
formatter.open_array_section("methods");
formatter.dump_string("methodname", "GET");
formatter.dump_string("methodname", "HEAD");
formatter.dump_string("methodname", "PUT");
formatter.dump_string("methodname", "POST");
formatter.dump_string("methodname", "DELETE");
formatter.close_section();
formatter.close_section();
}
void RGWInfo_ObjStore_SWIFT::list_slo_data(Formatter& formatter,
const ConfigProxy& config,
rgw::sal::Driver* driver)
{
formatter.open_object_section("slo");
formatter.dump_int("max_manifest_segments", config->rgw_max_slo_entries);
formatter.close_section();
}
bool RGWInfo_ObjStore_SWIFT::is_expired(const std::string& expires, const DoutPrefixProvider *dpp)
{
string err;
const utime_t now = ceph_clock_now();
const uint64_t expiration = (uint64_t)strict_strtoll(expires.c_str(),
10, &err);
if (!err.empty()) {
ldpp_dout(dpp, 5) << "failed to parse siginfo_expires: " << err << dendl;
return true;
}
if (expiration <= (uint64_t)now.sec()) {
ldpp_dout(dpp, 5) << "siginfo expired: " << expiration << " <= " << now.sec() << dendl;
return true;
}
return false;
}
void RGWFormPost::init(rgw::sal::Driver* const driver,
req_state* const s,
RGWHandler* const dialect_handler)
{
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(driver, s, dialect_handler);
}
std::size_t RGWFormPost::get_max_file_size() /*const*/
{
std::string max_str = get_part_str(ctrl_parts, "max_file_size", "0");
std::string err;
const std::size_t max_file_size =
static_cast<uint64_t>(strict_strtoll(max_str.c_str(), 10, &err));
if (! err.empty()) {
ldpp_dout(this, 5) << "failed to parse FormPost's max_file_size: " << err
<< dendl;
return 0;
}
return max_file_size;
}
bool RGWFormPost::is_non_expired()
{
std::string expires = get_part_str(ctrl_parts, "expires", "0");
std::string err;
const uint64_t expires_timestamp =
static_cast<uint64_t>(strict_strtoll(expires.c_str(), 10, &err));
if (! err.empty()) {
ldpp_dout(this, 5) << "failed to parse FormPost's expires: " << err << dendl;
return false;
}
const utime_t now = ceph_clock_now();
if (std::cmp_less_equal(expires_timestamp, now.sec())) {
ldpp_dout(this, 5) << "FormPost form expired: "
<< expires_timestamp << " <= " << now.sec() << dendl;
return false;
}
return true;
}
bool RGWFormPost::is_integral()
{
const std::string form_signature = get_part_str(ctrl_parts, "signature");
try {
get_owner_info(s, s->user->get_info());
s->auth.identity = rgw::auth::transform_old_authinfo(s);
} catch (...) {
ldpp_dout(this, 5) << "cannot get user_info of account's owner" << dendl;
return false;
}
for (const auto& kv : s->user->get_info().temp_url_keys) {
const int temp_url_key_num = kv.first;
const string& temp_url_key = kv.second;
if (temp_url_key.empty()) {
continue;
}
SignatureHelper sig_helper;
sig_helper.calc(temp_url_key,
s->info.request_uri,
get_part_str(ctrl_parts, "redirect"),
get_part_str(ctrl_parts, "max_file_size", "0"),
get_part_str(ctrl_parts, "max_file_count", "0"),
get_part_str(ctrl_parts, "expires", "0"));
const auto local_sig = sig_helper.get_signature();
ldpp_dout(this, 20) << "FormPost signature [" << temp_url_key_num << "]"
<< " (calculated): " << local_sig << dendl;
if (sig_helper.is_equal_to(form_signature)) {
return true;
} else {
ldpp_dout(this, 5) << "FormPost's signature mismatch: "
<< local_sig << " != " << form_signature << dendl;
}
}
return false;
}
void RGWFormPost::get_owner_info(const req_state* const s,
RGWUserInfo& owner_info) const
{
/* We cannot use req_state::bucket_name because it isn't available
* now. It will be initialized in RGWHandler_REST_SWIFT::postauth_init(). */
const string& bucket_name = s->init_state.url_bucket;
std::unique_ptr<rgw::sal::User> user;
/* TempURL in Formpost only requires that bucket name is specified. */
if (bucket_name.empty()) {
throw -EPERM;
}
if (!s->account_name.empty()) {
RGWUserInfo uinfo;
bool found = false;
const rgw_user uid(s->account_name);
if (uid.tenant.empty()) {
const rgw_user tenanted_uid(uid.id, uid.id);
user = driver->get_user(tenanted_uid);
if (user->load_user(s, s->yield) >= 0) {
/* Succeeded. */
found = true;
}
}
if (!found) {
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 = 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 = driver->get_user(bucket->get_info().owner);
if (user->load_user(s, s->yield) < 0) {
throw -EPERM;
}
owner_info = user->get_info();
}
int RGWFormPost::get_params(optional_yield y)
{
/* The parentt class extracts boundary info from the Content-Type. */
int ret = RGWPostObj_ObjStore::get_params(y);
if (ret < 0) {
return ret;
}
policy.create_default(s->user->get_id(), s->user->get_display_name());
/* Let's start parsing the HTTP body by parsing each form part step-
* by-step till encountering the first part with file data. */
do {
struct post_form_part part;
ret = read_form_part_header(&part, stream_done);
if (ret < 0) {
return ret;
}
if (s->cct->_conf->subsys.should_gather<ceph_subsys_rgw, 20>()) {
ldpp_dout(this, 20) << "read part header -- part.name="
<< part.name << dendl;
for (const auto& pair : part.fields) {
ldpp_dout(this, 20) << "field.name=" << pair.first << dendl;
ldpp_dout(this, 20) << "field.val=" << pair.second.val << dendl;
ldpp_dout(this, 20) << "field.params:" << dendl;
for (const auto& param_pair : pair.second.params) {
ldpp_dout(this, 20) << " " << param_pair.first
<< " -> " << param_pair.second << dendl;
}
}
}
if (stream_done) {
/* Unexpected here. */
err_msg = "Malformed request";
return -EINVAL;
}
const auto field_iter = part.fields.find("Content-Disposition");
if (std::end(part.fields) != field_iter &&
std::end(field_iter->second.params) != field_iter->second.params.find("filename")) {
/* First data part ahead. */
current_data_part = std::move(part);
/* Stop the iteration. We can assume that all control parts have been
* already parsed. The rest of HTTP body should contain data parts
* only. They will be picked up by ::get_data(). */
break;
} else {
/* 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);
if (ret < 0) {
return ret;
} else if (! boundary) {
err_msg = "Couldn't find boundary";
return -EINVAL;
}
ctrl_parts[part.name] = std::move(part);
}
} while (! stream_done);
min_len = 0;
max_len = get_max_file_size();
if (! current_data_part) {
err_msg = "FormPost: no files to process";
return -EINVAL;
}
if (! is_non_expired()) {
err_msg = "FormPost: Form Expired";
return -EPERM;
}
if (! is_integral()) {
err_msg = "FormPost: Invalid Signature";
return -EPERM;
}
return 0;
}
std::string RGWFormPost::get_current_filename() const
{
try {
const auto& field = current_data_part->fields.at("Content-Disposition");
const auto iter = field.params.find("filename");
if (std::end(field.params) != iter) {
return prefix + iter->second;
}
} catch (std::out_of_range&) {
/* NOP */;
}
return prefix;
}
std::string RGWFormPost::get_current_content_type() const
{
try {
const auto& field = current_data_part->fields.at("Content-Type");
return field.val;
} catch (std::out_of_range&) {
/* NOP */;
}
return std::string();
}
bool RGWFormPost::is_next_file_to_upload()
{
if (! stream_done) {
/* We have at least one additional part in the body. */
struct post_form_part part;
int r = read_form_part_header(&part, stream_done);
if (r < 0) {
return false;
}
const auto field_iter = part.fields.find("Content-Disposition");
if (std::end(part.fields) != field_iter) {
const auto& params = field_iter->second.params;
const auto& filename_iter = params.find("filename");
if (std::end(params) != filename_iter && ! filename_iter->second.empty()) {
current_data_part = std::move(part);
return true;
}
}
}
return false;
}
int RGWFormPost::get_data(ceph::bufferlist& bl, bool& again)
{
bool boundary;
int r = read_data(bl, s->cct->_conf->rgw_max_chunk_size,
boundary, stream_done);
if (r < 0) {
return r;
}
/* Tell RGWPostObj::execute(optional_yield y) that it has some data to put. */
again = !boundary;
return bl.length();
}
void RGWFormPost::send_response()
{
std::string redirect = get_part_str(ctrl_parts, "redirect");
if (! redirect.empty()) {
op_ret = STATUS_REDIRECT;
}
set_req_state_err(s, op_ret);
s->err.err_code = err_msg;
dump_errno(s);
if (! redirect.empty()) {
dump_redirect(s, redirect);
}
end_header(s, this);
}
bool RGWFormPost::is_formpost_req(req_state* const s)
{
std::string content_type;
std::map<std::string, std::string> params;
parse_boundary_params(s->info.env->get("CONTENT_TYPE", ""),
content_type, params);
return boost::algorithm::iequals(content_type, "multipart/form-data") &&
params.count("boundary") > 0;
}
RGWOp *RGWHandler_REST_Service_SWIFT::op_get()
{
return new RGWListBuckets_ObjStore_SWIFT;
}
RGWOp *RGWHandler_REST_Service_SWIFT::op_head()
{
return new RGWStatAccount_ObjStore_SWIFT;
}
RGWOp *RGWHandler_REST_Service_SWIFT::op_put()
{
if (s->info.args.exists("extract-archive")) {
return new RGWBulkUploadOp_ObjStore_SWIFT;
}
return nullptr;
}
RGWOp *RGWHandler_REST_Service_SWIFT::op_post()
{
if (s->info.args.exists("bulk-delete")) {
return new RGWBulkDelete_ObjStore_SWIFT;
}
return new RGWPutMetadataAccount_ObjStore_SWIFT;
}
RGWOp *RGWHandler_REST_Service_SWIFT::op_delete()
{
if (s->info.args.exists("bulk-delete")) {
return new RGWBulkDelete_ObjStore_SWIFT;
}
return NULL;
}
int RGWSwiftWebsiteHandler::serve_errordoc(const int http_ret,
const std::string error_doc,
optional_yield y)
{
/* Try to throw it all away. */
s->formatter->reset();
class RGWGetErrorPage : public RGWGetObj_ObjStore_SWIFT {
public:
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(driver, s, handler);
set_get_data(true);
set_custom_http_response(http_ret);
}
int error_handler(const int err_no,
std::string* const error_content, optional_yield y) override {
/* Enforce that any error generated while getting the error page will
* not be send to a client. This allows us to recover from the double
* fault situation by sending the original message. */
return 0;
}
} 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
* are set up. */
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 = 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, driver, true);
}
int RGWSwiftWebsiteHandler::error_handler(const int err_no,
std::string* const error_content,
optional_yield y)
{
if (!s->bucket.get()) {
/* No bucket, default no-op handler */
return err_no;
}
const auto& ws_conf = s->bucket->get_info().website_conf;
if (can_be_website_req() && ! ws_conf.error_doc.empty()) {
set_req_state_err(s, err_no);
return serve_errordoc(s->err.http_ret, ws_conf.error_doc, y);
}
/* Let's go to the default, no-op handler. */
return err_no;
}
bool RGWSwiftWebsiteHandler::is_web_mode() const
{
const std::string_view webmode = s->info.env->get("HTTP_X_WEB_MODE", "");
return boost::algorithm::iequals(webmode, "true");
}
bool RGWSwiftWebsiteHandler::can_be_website_req() const
{
/* Static website works only with the GET or HEAD method. Nothing more. */
static const std::set<std::string_view> ws_methods = { "GET", "HEAD" };
if (ws_methods.count(s->info.method) == 0) {
return false;
}
/* We also need to handle early failures from the auth system. In such cases
* req_state::auth.identity may be empty. Let's treat that the same way as
* the anonymous access. */
if (! s->auth.identity) {
return true;
}
/* Swift serves websites only for anonymous requests unless client explicitly
* requested this behaviour by supplying X-Web-Mode HTTP header set to true. */
if (s->auth.identity->is_anonymous() || is_web_mode()) {
return true;
}
return false;
}
RGWOp* RGWSwiftWebsiteHandler::get_ws_redirect_op()
{
class RGWMovedPermanently: public RGWOp {
const std::string location;
public:
explicit RGWMovedPermanently(const std::string& location)
: location(location) {
}
int verify_permission(optional_yield) override {
return 0;
}
void execute(optional_yield) override {
op_ret = -ERR_PERMANENT_REDIRECT;
return;
}
void send_response() override {
set_req_state_err(s, op_ret);
dump_errno(s);
dump_content_length(s, 0);
dump_redirect(s, location);
end_header(s, this);
}
const char* name() const override {
return "RGWMovedPermanently";
}
};
return new RGWMovedPermanently(s->info.request_uri + '/');
}
RGWOp* RGWSwiftWebsiteHandler::get_ws_index_op()
{
/* Retarget to get obj on requested index file. */
if (! s->object->empty()) {
s->object->set_name(s->object->get_name() +
s->bucket->get_info().website_conf.get_index_doc());
} else {
s->object->set_name(s->bucket->get_info().website_conf.get_index_doc());
}
auto getop = new RGWGetObj_ObjStore_SWIFT;
getop->set_get_data(boost::algorithm::equals("GET", s->info.method));
return getop;
}
RGWOp* RGWSwiftWebsiteHandler::get_ws_listing_op()
{
class RGWWebsiteListing : public RGWListBucket_ObjStore_SWIFT {
const std::string prefix_override;
int get_params(optional_yield) override {
prefix = prefix_override;
max = default_max;
delimiter = "/";
return 0;
}
void send_response() override {
/* Generate the header now. */
set_req_state_err(s, op_ret);
dump_errno(s);
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) {
return;
}
/* Now it's the time to start generating HTML bucket listing.
* All the crazy stuff with crafting tags will be delegated to
* RGWSwiftWebsiteListingFormatter. */
std::stringstream ss;
RGWSwiftWebsiteListingFormatter htmler(ss, prefix);
const auto& ws_conf = s->bucket->get_info().website_conf;
htmler.generate_header(s->decoded_uri,
ws_conf.listing_css_doc);
for (const auto& pair : common_prefixes) {
std::string subdir_name = pair.first;
if (! subdir_name.empty()) {
/* To be compliant with Swift we need to remove the trailing
* slash. */
subdir_name.pop_back();
}
htmler.dump_subdir(subdir_name);
}
for (const rgw_bucket_dir_entry& obj : objs) {
if (! common_prefixes.count(obj.key.name + '/')) {
htmler.dump_object(obj);
}
}
htmler.generate_footer();
dump_body(s, ss.str());
}
public:
/* Taking prefix_override by value to leverage std::string r-value ref
* ctor and thus avoid extra memory copying/increasing ref counter. */
explicit RGWWebsiteListing(std::string prefix_override)
: prefix_override(std::move(prefix_override)) {
}
};
std::string prefix = std::move(s->object->get_name());
s->object->set_key(rgw_obj_key());
return new RGWWebsiteListing(std::move(prefix));
}
bool RGWSwiftWebsiteHandler::is_web_dir() const
{
std::string subdir_name = url_decode(s->object->get_name());
/* Remove character from the subdir name if it is "/". */
if (subdir_name.empty()) {
return false;
} else if (subdir_name.back() == '/') {
subdir_name.pop_back();
if (subdir_name.empty()) {
return false;
}
}
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. */
obj->set_atomic();
obj->set_prefetch_data();
RGWObjState* state = nullptr;
if (obj->get_obj_state(s, &state, s->yield, false)) {
return false;
}
/* A nonexistent object cannot be a considered as a marker representing
* the emulation of catalog in FS hierarchy. */
if (! state->exists) {
return false;
}
/* Decode the content type. */
std::string content_type;
get_contype_from_attrs(state->attrset, content_type);
const auto& ws_conf = s->bucket->get_info().website_conf;
const std::string subdir_marker = ws_conf.subdir_marker.empty()
? "application/directory"
: ws_conf.subdir_marker;
return subdir_marker == content_type && state->size <= 1;
}
bool RGWSwiftWebsiteHandler::is_index_present(const std::string& index) const
{
std::unique_ptr<rgw::sal::Object> obj = s->bucket->get_object(rgw_obj_key(index));
obj->set_atomic();
obj->set_prefetch_data();
RGWObjState* state = nullptr;
if (obj->get_obj_state(s, &state, s->yield, false)) {
return false;
}
/* A nonexistent object cannot be a considered as a viable index. We will
* try to list the bucket or - if this is impossible - return an error. */
return state->exists;
}
int RGWSwiftWebsiteHandler::retarget_bucket(RGWOp* op, RGWOp** new_op)
{
ldpp_dout(s, 10) << "Starting retarget" << dendl;
RGWOp* op_override = nullptr;
/* In Swift static web content is served if the request is anonymous or
* has X-Web-Mode HTTP header specified to true. */
if (can_be_website_req()) {
const auto& ws_conf = s->bucket->get_info().website_conf;
const auto& index = s->bucket->get_info().website_conf.get_index_doc();
if (s->decoded_uri.back() != '/') {
op_override = get_ws_redirect_op();
} else if (! index.empty() && is_index_present(index)) {
op_override = get_ws_index_op();
} else if (ws_conf.listing_enabled) {
op_override = get_ws_listing_op();
}
}
if (op_override) {
handler->put_op(op);
op_override->init(driver, s, handler);
*new_op = op_override;
} else {
*new_op = op;
}
/* Return 404 Not Found is the request has web mode enforced but we static web
* wasn't able to serve it accordingly. */
return ! op_override && is_web_mode() ? -ENOENT : 0;
}
int RGWSwiftWebsiteHandler::retarget_object(RGWOp* op, RGWOp** new_op)
{
ldpp_dout(s, 10) << "Starting object retarget" << dendl;
RGWOp* op_override = nullptr;
/* In Swift static web content is served if the request is anonymous or
* has X-Web-Mode HTTP header specified to true. */
if (can_be_website_req() && is_web_dir()) {
const auto& ws_conf = s->bucket->get_info().website_conf;
const auto& index = s->bucket->get_info().website_conf.get_index_doc();
if (s->decoded_uri.back() != '/') {
op_override = get_ws_redirect_op();
} else if (! index.empty() && is_index_present(index)) {
op_override = get_ws_index_op();
} else if (ws_conf.listing_enabled) {
op_override = get_ws_listing_op();
}
} else {
/* A regular request or the specified object isn't a subdirectory marker.
* We don't need any re-targeting. Error handling (like sending a custom
* error page) will be performed by error_handler of the actual RGWOp. */
return 0;
}
if (op_override) {
handler->put_op(op);
op_override->init(driver, s, handler);
*new_op = op_override;
} else {
*new_op = op;
}
/* Return 404 Not Found if we aren't able to re-target for subdir marker. */
return ! op_override ? -ENOENT : 0;
}
RGWOp *RGWHandler_REST_Bucket_SWIFT::get_obj_op(bool get_data)
{
if (is_acl_op()) {
return new RGWGetACLs_ObjStore_SWIFT;
}
if (get_data)
return new RGWListBucket_ObjStore_SWIFT;
else
return new RGWStatBucket_ObjStore_SWIFT;
}
RGWOp *RGWHandler_REST_Bucket_SWIFT::op_get()
{
return get_obj_op(true);
}
RGWOp *RGWHandler_REST_Bucket_SWIFT::op_head()
{
return get_obj_op(false);
}
RGWOp *RGWHandler_REST_Bucket_SWIFT::op_put()
{
if (is_acl_op()) {
return new RGWPutACLs_ObjStore_SWIFT;
}
if(s->info.args.exists("extract-archive")) {
return new RGWBulkUploadOp_ObjStore_SWIFT;
}
return new RGWCreateBucket_ObjStore_SWIFT;
}
RGWOp *RGWHandler_REST_Bucket_SWIFT::op_delete()
{
return new RGWDeleteBucket_ObjStore_SWIFT;
}
RGWOp *RGWHandler_REST_Bucket_SWIFT::op_post()
{
if (RGWFormPost::is_formpost_req(s)) {
return new RGWFormPost;
} else {
return new RGWPutMetadataBucket_ObjStore_SWIFT;
}
}
RGWOp *RGWHandler_REST_Bucket_SWIFT::op_options()
{
return new RGWOptionsCORS_ObjStore_SWIFT;
}
RGWOp *RGWHandler_REST_Obj_SWIFT::get_obj_op(bool get_data)
{
if (is_acl_op()) {
return new RGWGetACLs_ObjStore_SWIFT;
}
RGWGetObj_ObjStore_SWIFT *get_obj_op = new RGWGetObj_ObjStore_SWIFT;
get_obj_op->set_get_data(get_data);
return get_obj_op;
}
RGWOp *RGWHandler_REST_Obj_SWIFT::op_get()
{
return get_obj_op(true);
}
RGWOp *RGWHandler_REST_Obj_SWIFT::op_head()
{
return get_obj_op(false);
}
RGWOp *RGWHandler_REST_Obj_SWIFT::op_put()
{
if (is_acl_op()) {
return new RGWPutACLs_ObjStore_SWIFT;
}
if(s->info.args.exists("extract-archive")) {
return new RGWBulkUploadOp_ObjStore_SWIFT;
}
if (s->init_state.src_bucket.empty())
return new RGWPutObj_ObjStore_SWIFT;
else
return new RGWCopyObj_ObjStore_SWIFT;
}
RGWOp *RGWHandler_REST_Obj_SWIFT::op_delete()
{
return new RGWDeleteObj_ObjStore_SWIFT;
}
RGWOp *RGWHandler_REST_Obj_SWIFT::op_post()
{
if (RGWFormPost::is_formpost_req(s)) {
return new RGWFormPost;
} else {
return new RGWPutMetadataObject_ObjStore_SWIFT;
}
}
RGWOp *RGWHandler_REST_Obj_SWIFT::op_copy()
{
return new RGWCopyObj_ObjStore_SWIFT;
}
RGWOp *RGWHandler_REST_Obj_SWIFT::op_options()
{
return new RGWOptionsCORS_ObjStore_SWIFT;
}
int RGWHandler_REST_SWIFT::authorize(const DoutPrefixProvider *dpp, optional_yield y)
{
return rgw::auth::Strategy::apply(dpp, auth_strategy, s, y);
}
int RGWHandler_REST_SWIFT::postauth_init(optional_yield y)
{
struct req_init_state* t = &s->init_state;
/* XXX Stub this until Swift Auth sets account into URL. */
if (g_conf()->rgw_swift_account_in_url
&& s->user->get_id().id == RGW_USER_ANON_ID) {
s->bucket_tenant = s->account_name;
} else {
s->bucket_tenant = s->user->get_tenant();
}
s->bucket_name = t->url_bucket;
if (!s->object) {
/* Need an object, even an empty one */
s->object = driver->get_object(rgw_obj_key());
}
ldpp_dout(s, 10) << "s->object=" <<
(!s->object->empty() ? s->object->get_key() : rgw_obj_key("<NULL>"))
<< " s->bucket="
<< rgw_make_bucket_entry_name(s->bucket_tenant, s->bucket_name)
<< dendl;
int ret;
ret = rgw_validate_tenant_name(s->bucket_tenant);
if (ret)
return ret;
ret = validate_bucket_name(s->bucket_name);
if (ret)
return ret;
ret = validate_object_name(s->object->get_name());
if (ret)
return ret;
if (!t->src_bucket.empty()) {
/*
* We don't allow cross-tenant copy at present. It requires account
* names in the URL for Swift.
*/
s->src_tenant_name = s->user->get_tenant();
s->src_bucket_name = t->src_bucket;
ret = validate_bucket_name(s->src_bucket_name);
if (ret < 0) {
return ret;
}
ret = validate_object_name(s->src_object->get_name());
if (ret < 0) {
return ret;
}
}
return 0;
}
int RGWHandler_REST_SWIFT::validate_bucket_name(const string& bucket)
{
const size_t len = bucket.size();
if (len > MAX_BUCKET_NAME_LEN) {
/* Bucket Name too long. Generate custom error message and bind it
* to an R-value reference. */
const auto msg = boost::str(
boost::format("Container name length of %lld longer than %lld")
% len % int(MAX_BUCKET_NAME_LEN));
set_req_state_err(s, ERR_INVALID_BUCKET_NAME, msg);
return -ERR_INVALID_BUCKET_NAME;
}
if (len == 0)
return 0;
if (bucket[0] == '.')
return -ERR_INVALID_BUCKET_NAME;
if (check_utf8(bucket.c_str(), len))
return -ERR_INVALID_UTF8;
const char *s = bucket.c_str();
for (size_t i = 0; i < len; ++i, ++s) {
if (*(unsigned char *)s == 0xff)
return -ERR_INVALID_BUCKET_NAME;
if (*(unsigned char *)s == '/')
return -ERR_INVALID_BUCKET_NAME;
}
return 0;
}
static void next_tok(string& str, string& tok, char delim)
{
if (str.size() == 0) {
tok = "";
return;
}
tok = str;
int pos = str.find(delim);
if (pos > 0) {
tok = str.substr(0, pos);
str = str.substr(pos + 1);
} else {
str = "";
}
}
int RGWHandler_REST_SWIFT::init_from_header(rgw::sal::Driver* driver,
req_state* const s,
const std::string& frontend_prefix)
{
string req;
string first;
s->prot_flags |= RGW_REST_SWIFT;
char reqbuf[frontend_prefix.length() + s->decoded_uri.length() + 1];
sprintf(reqbuf, "%s%s", frontend_prefix.c_str(), s->decoded_uri.c_str());
const char *req_name = reqbuf;
const char *p;
if (*req_name == '?') {
p = req_name;
} else {
p = s->info.request_params.c_str();
}
s->info.args.set(p);
s->info.args.parse(s);
/* Skip the leading slash of URL hierarchy. */
if (req_name[0] != '/') {
return 0;
} else {
req_name++;
}
if ('\0' == req_name[0]) {
return g_conf()->rgw_swift_url_prefix == "/" ? -ERR_BAD_URL : 0;
}
req = req_name;
size_t pos = req.find('/');
if (std::string::npos != pos && g_conf()->rgw_swift_url_prefix != "/") {
bool cut_url = g_conf()->rgw_swift_url_prefix.length();
first = req.substr(0, pos);
if (first.compare(g_conf()->rgw_swift_url_prefix) == 0) {
if (cut_url) {
/* Rewind to the "v1/..." part. */
next_tok(req, first, '/');
}
}
} else if (req.compare(g_conf()->rgw_swift_url_prefix) == 0) {
s->formatter = new RGWFormatter_Plain;
return -ERR_BAD_URL;
} else {
first = req;
}
std::string tenant_path;
if (! g_conf()->rgw_swift_tenant_name.empty()) {
tenant_path = "/AUTH_";
tenant_path.append(g_conf()->rgw_swift_tenant_name);
}
/* verify that the request_uri conforms with what's expected */
char buf[g_conf()->rgw_swift_url_prefix.length() + 16 + tenant_path.length()];
int blen;
if (g_conf()->rgw_swift_url_prefix == "/") {
blen = sprintf(buf, "/v1%s", tenant_path.c_str());
} else {
blen = sprintf(buf, "/%s/v1%s",
g_conf()->rgw_swift_url_prefix.c_str(), tenant_path.c_str());
}
if (strncmp(reqbuf, buf, blen) != 0) {
return -ENOENT;
}
int ret = allocate_formatter(s, RGWFormat::PLAIN, true);
if (ret < 0)
return ret;
string ver;
next_tok(req, ver, '/');
if (!tenant_path.empty() || g_conf()->rgw_swift_account_in_url) {
string account_name;
next_tok(req, account_name, '/');
/* Erase all pre-defined prefixes like "AUTH_" or "KEY_". */
const vector<string> skipped_prefixes = { "AUTH_", "KEY_" };
for (const auto& pfx : skipped_prefixes) {
const size_t comp_len = min(account_name.length(), pfx.length());
if (account_name.compare(0, comp_len, pfx) == 0) {
/* Prefix is present. Drop it. */
account_name = account_name.substr(comp_len);
break;
}
}
if (account_name.empty()) {
return -ERR_PRECONDITION_FAILED;
} else {
s->account_name = account_name;
}
}
next_tok(req, first, '/');
ldpp_dout(s, 10) << "ver=" << ver << " first=" << first << " req=" << req << dendl;
if (first.size() == 0)
return 0;
s->info.effective_uri = "/" + first;
// Save bucket to tide us over until token is parsed.
s->init_state.url_bucket = first;
if (req.size()) {
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::Driver* driver, req_state* s,
rgw::io::BasicClient *cio)
{
struct req_init_state *t = &s->init_state;
s->dialect = "swift";
std::string copy_source = s->info.env->get("HTTP_X_COPY_FROM", "");
if (! copy_source.empty()) {
rgw_obj_key key;
bool result = RGWCopyObj::parse_copy_location(copy_source, t->src_bucket, key, s);
if (!result)
return -ERR_BAD_URL;
s->src_object = driver->get_object(key);
if (!s->src_object)
return -ERR_BAD_URL;
}
if (s->op == OP_COPY) {
std::string req_dest = s->info.env->get("HTTP_DESTINATION", "");
if (req_dest.empty())
return -ERR_BAD_URL;
std::string dest_bucket_name;
rgw_obj_key dest_obj_key;
bool result =
RGWCopyObj::parse_copy_location(req_dest, dest_bucket_name,
dest_obj_key, s);
if (!result)
return -ERR_BAD_URL;
std::string dest_object_name = dest_obj_key.name;
/* convert COPY operation into PUT */
t->src_bucket = t->url_bucket;
s->src_object = s->object->clone();
t->url_bucket = dest_bucket_name;
s->object->set_name(dest_object_name);
s->op = OP_PUT;
}
s->info.storage_class = s->info.env->get("HTTP_X_OBJECT_STORAGE_CLASS", "");
return RGWHandler_REST::init(driver, s, cio);
}
RGWHandler_REST*
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(driver, s, frontend_prefix);
if (ret < 0) {
ldpp_dout(s, 10) << "init_from_header returned err=" << ret << dendl;
return nullptr;
}
const auto& auth_strategy = auth_registry.get_swift();
if (s->init_state.url_bucket.empty()) {
return new RGWHandler_REST_Service_SWIFT(auth_strategy);
}
if (rgw::sal::Object::empty(s->object.get())) {
return new RGWHandler_REST_Bucket_SWIFT(auth_strategy);
}
return new RGWHandler_REST_Obj_SWIFT(auth_strategy);
}
RGWHandler_REST* RGWRESTMgr_SWIFT_Info::get_handler(
rgw::sal::Driver* driver,
req_state* const s,
const rgw::auth::StrategyRegistry& auth_registry,
const std::string& frontend_prefix)
{
s->prot_flags |= RGW_REST_SWIFT;
const auto& auth_strategy = auth_registry.get_swift();
return new RGWHandler_REST_SWIFT_Info(auth_strategy);
}
| 91,787 | 28.362764 | 111 |
cc
|
null |
ceph-main/src/rgw/rgw_rest_swift.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#pragma once
#define TIME_BUF_SIZE 128
#include <string_view>
#include <boost/optional.hpp>
#include <boost/utility/typed_in_place_factory.hpp>
#include "rgw_op.h"
#include "rgw_rest.h"
#include "rgw_swift_auth.h"
#include "rgw_http_errors.h"
class RGWGetObj_ObjStore_SWIFT : public RGWGetObj_ObjStore {
int custom_http_ret = 0;
public:
RGWGetObj_ObjStore_SWIFT() {}
~RGWGetObj_ObjStore_SWIFT() override {}
int verify_permission(optional_yield y) override;
int get_params(optional_yield y) override;
int send_response_data_error(optional_yield y) override;
int send_response_data(bufferlist& bl, off_t ofs, off_t len) override;
void set_custom_http_response(const int http_ret) {
custom_http_ret = http_ret;
}
bool need_object_expiration() override {
return true;
}
};
class RGWListBuckets_ObjStore_SWIFT : public RGWListBuckets_ObjStore {
bool need_stats;
bool wants_reversed;
std::string prefix;
std::vector<rgw::sal::BucketList> reverse_buffer;
uint64_t get_default_max() const override {
return 0;
}
public:
RGWListBuckets_ObjStore_SWIFT()
: need_stats(true),
wants_reversed(false) {
}
~RGWListBuckets_ObjStore_SWIFT() override {}
int get_params(optional_yield y) override;
void handle_listing_chunk(rgw::sal::BucketList&& buckets) override;
void send_response_begin(bool has_buckets) override;
void send_response_data(rgw::sal::BucketList& buckets) override;
void send_response_data_reversed(rgw::sal::BucketList& buckets);
void dump_bucket_entry(const rgw::sal::Bucket& obj);
void send_response_end() override;
bool should_get_stats() override { return need_stats; }
bool supports_account_metadata() override { return true; }
};
class RGWListBucket_ObjStore_SWIFT : public RGWListBucket_ObjStore {
std::string path;
public:
RGWListBucket_ObjStore_SWIFT() {
default_max = 10000;
}
~RGWListBucket_ObjStore_SWIFT() override {}
int get_params(optional_yield y) override;
void send_response() override;
bool need_container_stats() override { return true; }
};
class RGWStatAccount_ObjStore_SWIFT : public RGWStatAccount_ObjStore {
std::map<std::string, bufferlist> attrs;
public:
RGWStatAccount_ObjStore_SWIFT() {
}
~RGWStatAccount_ObjStore_SWIFT() override {}
void execute(optional_yield y) override;
void send_response() override;
};
class RGWStatBucket_ObjStore_SWIFT : public RGWStatBucket_ObjStore {
public:
RGWStatBucket_ObjStore_SWIFT() {}
~RGWStatBucket_ObjStore_SWIFT() override {}
void send_response() override;
};
class RGWCreateBucket_ObjStore_SWIFT : public RGWCreateBucket_ObjStore {
protected:
bool need_metadata_upload() const override { return true; }
public:
RGWCreateBucket_ObjStore_SWIFT() {}
~RGWCreateBucket_ObjStore_SWIFT() override {}
int get_params(optional_yield y) override;
void send_response() override;
};
class RGWDeleteBucket_ObjStore_SWIFT : public RGWDeleteBucket_ObjStore {
public:
RGWDeleteBucket_ObjStore_SWIFT() {}
~RGWDeleteBucket_ObjStore_SWIFT() override {}
void send_response() override;
};
class RGWPutObj_ObjStore_SWIFT : public RGWPutObj_ObjStore {
std::string lo_etag;
public:
RGWPutObj_ObjStore_SWIFT() {}
~RGWPutObj_ObjStore_SWIFT() override {}
int update_slo_segment_size(rgw_slo_entry& entry);
int verify_permission(optional_yield y) override;
int get_params(optional_yield y) override;
void send_response() override;
};
class RGWPutMetadataAccount_ObjStore_SWIFT : public RGWPutMetadataAccount_ObjStore {
public:
RGWPutMetadataAccount_ObjStore_SWIFT() {}
~RGWPutMetadataAccount_ObjStore_SWIFT() override {}
int get_params(optional_yield y) override;
void send_response() override;
};
class RGWPutMetadataBucket_ObjStore_SWIFT : public RGWPutMetadataBucket_ObjStore {
public:
RGWPutMetadataBucket_ObjStore_SWIFT() {}
~RGWPutMetadataBucket_ObjStore_SWIFT() override {}
int get_params(optional_yield y) override;
void send_response() override;
};
class RGWPutMetadataObject_ObjStore_SWIFT : public RGWPutMetadataObject_ObjStore {
public:
RGWPutMetadataObject_ObjStore_SWIFT() {}
~RGWPutMetadataObject_ObjStore_SWIFT() override {}
int get_params(optional_yield y) override;
void send_response() override;
bool need_object_expiration() override { return true; }
};
class RGWDeleteObj_ObjStore_SWIFT : public RGWDeleteObj_ObjStore {
public:
RGWDeleteObj_ObjStore_SWIFT() {}
~RGWDeleteObj_ObjStore_SWIFT() override {}
int verify_permission(optional_yield y) override;
int get_params(optional_yield y) override;
bool need_object_expiration() override { return true; }
void send_response() override;
};
class RGWCopyObj_ObjStore_SWIFT : public RGWCopyObj_ObjStore {
bool sent_header;
protected:
void dump_copy_info();
public:
RGWCopyObj_ObjStore_SWIFT() : sent_header(false) {}
~RGWCopyObj_ObjStore_SWIFT() override {}
int init_dest_policy() override;
int get_params(optional_yield y) override;
void send_response() override;
void send_partial_response(off_t ofs) override;
};
class RGWGetACLs_ObjStore_SWIFT : public RGWGetACLs_ObjStore {
public:
RGWGetACLs_ObjStore_SWIFT() {}
~RGWGetACLs_ObjStore_SWIFT() override {}
void send_response() override {}
};
class RGWPutACLs_ObjStore_SWIFT : public RGWPutACLs_ObjStore {
public:
RGWPutACLs_ObjStore_SWIFT() : RGWPutACLs_ObjStore() {}
~RGWPutACLs_ObjStore_SWIFT() override {}
void send_response() override {}
};
class RGWOptionsCORS_ObjStore_SWIFT : public RGWOptionsCORS_ObjStore {
public:
RGWOptionsCORS_ObjStore_SWIFT() {}
~RGWOptionsCORS_ObjStore_SWIFT() override {}
void send_response() override;
};
class RGWBulkDelete_ObjStore_SWIFT : public RGWBulkDelete_ObjStore {
public:
RGWBulkDelete_ObjStore_SWIFT() {}
~RGWBulkDelete_ObjStore_SWIFT() override {}
int get_data(std::list<RGWBulkDelete::acct_path_t>& items,
bool * is_truncated) override;
void send_response() override;
};
class RGWBulkUploadOp_ObjStore_SWIFT : public RGWBulkUploadOp_ObjStore {
size_t conlen;
size_t curpos;
public:
RGWBulkUploadOp_ObjStore_SWIFT()
: conlen(0),
curpos(0) {
}
~RGWBulkUploadOp_ObjStore_SWIFT() = default;
std::unique_ptr<StreamGetter> create_stream() override;
void send_response() override;
};
class RGWInfo_ObjStore_SWIFT : public RGWInfo_ObjStore {
protected:
struct info
{
bool is_admin_info;
std::function<void (Formatter&, const ConfigProxy&, rgw::sal::Driver*)> list_data;
};
static const std::vector<std::pair<std::string, struct info>> swift_info;
public:
RGWInfo_ObjStore_SWIFT() {}
~RGWInfo_ObjStore_SWIFT() override {}
void execute(optional_yield y) override;
void send_response() override;
static void list_swift_data(Formatter& formatter, const ConfigProxy& config, rgw::sal::Driver* driver);
static void list_tempauth_data(Formatter& formatter, const ConfigProxy& config, rgw::sal::Driver* driver);
static void list_tempurl_data(Formatter& formatter, const ConfigProxy& config, rgw::sal::Driver* driver);
static void list_slo_data(Formatter& formatter, const ConfigProxy& config, rgw::sal::Driver* driver);
static bool is_expired(const std::string& expires, const DoutPrefixProvider* dpp);
};
class RGWFormPost : public RGWPostObj_ObjStore {
std::string get_current_filename() const override;
std::string get_current_content_type() const override;
std::size_t get_max_file_size() /*const*/;
bool is_next_file_to_upload() override;
bool is_integral();
bool is_non_expired();
void get_owner_info(const req_state* s,
RGWUserInfo& owner_info) const;
parts_collection_t ctrl_parts;
boost::optional<post_form_part> current_data_part;
std::string prefix;
bool stream_done = false;
class SignatureHelper;
public:
RGWFormPost() = default;
~RGWFormPost() = default;
void init(rgw::sal::Driver* driver,
req_state* s,
RGWHandler* dialect_handler) override;
int get_params(optional_yield y) override;
int get_data(ceph::bufferlist& bl, bool& again) override;
void send_response() override;
static bool is_formpost_req(req_state* const s);
};
class RGWFormPost::SignatureHelper
{
private:
static constexpr uint32_t output_size =
CEPH_CRYPTO_HMACSHA1_DIGESTSIZE * 2 + 1;
unsigned char dest[CEPH_CRYPTO_HMACSHA1_DIGESTSIZE]; // 20
char dest_str[output_size];
public:
SignatureHelper() = default;
const char* calc(const std::string& key,
const std::string_view& path_info,
const std::string_view& redirect,
const std::string_view& max_file_size,
const std::string_view& max_file_count,
const std::string_view& expires) {
using ceph::crypto::HMACSHA1;
using UCHARPTR = const unsigned char*;
HMACSHA1 hmac((UCHARPTR) key.data(), key.size());
hmac.Update((UCHARPTR) path_info.data(), path_info.size());
hmac.Update((UCHARPTR) "\n", 1);
hmac.Update((UCHARPTR) redirect.data(), redirect.size());
hmac.Update((UCHARPTR) "\n", 1);
hmac.Update((UCHARPTR) max_file_size.data(), max_file_size.size());
hmac.Update((UCHARPTR) "\n", 1);
hmac.Update((UCHARPTR) max_file_count.data(), max_file_count.size());
hmac.Update((UCHARPTR) "\n", 1);
hmac.Update((UCHARPTR) expires.data(), expires.size());
hmac.Final(dest);
buf_to_hex((UCHARPTR) dest, sizeof(dest), dest_str);
return dest_str;
}
const char* get_signature() const {
return dest_str;
}
bool is_equal_to(const std::string& rhs) const {
/* never allow out-of-range exception */
if (rhs.size() < (output_size - 1)) {
return false;
}
return rhs.compare(0 /* pos */, output_size, dest_str) == 0;
}
}; /* RGWFormPost::SignatureHelper */
class RGWSwiftWebsiteHandler {
rgw::sal::Driver* const driver;
req_state* const s;
RGWHandler_REST* const handler;
bool is_web_mode() const;
bool can_be_website_req() const;
bool is_web_dir() const;
bool is_index_present(const std::string& index) const;
int serve_errordoc(int http_ret, std::string error_doc, optional_yield y);
RGWOp* get_ws_redirect_op();
RGWOp* get_ws_index_op();
RGWOp* get_ws_listing_op();
public:
RGWSwiftWebsiteHandler(rgw::sal::Driver* const driver,
req_state* const s,
RGWHandler_REST* const handler)
: driver(driver),
s(s),
handler(handler) {
}
int error_handler(const int err_no,
std::string* const error_content,
optional_yield y);
int retarget_bucket(RGWOp* op, RGWOp** new_op);
int retarget_object(RGWOp* op, RGWOp** new_op);
};
class RGWHandler_REST_SWIFT : public RGWHandler_REST {
friend class RGWRESTMgr_SWIFT;
friend class RGWRESTMgr_SWIFT_Info;
protected:
const rgw::auth::Strategy& auth_strategy;
virtual bool is_acl_op() const {
return false;
}
static int init_from_header(rgw::sal::Driver* driver, req_state* s,
const std::string& frontend_prefix);
public:
explicit RGWHandler_REST_SWIFT(const rgw::auth::Strategy& auth_strategy)
: auth_strategy(auth_strategy) {
}
~RGWHandler_REST_SWIFT() override = default;
int validate_bucket_name(const std::string& bucket);
int init(rgw::sal::Driver* driver, req_state *s, rgw::io::BasicClient *cio) override;
int authorize(const DoutPrefixProvider *dpp, optional_yield y) override;
int postauth_init(optional_yield y) override;
RGWAccessControlPolicy *alloc_policy() { return nullptr; /* return new RGWAccessControlPolicy_SWIFT; */ }
void free_policy(RGWAccessControlPolicy *policy) { delete policy; }
};
class RGWHandler_REST_Service_SWIFT : public RGWHandler_REST_SWIFT {
protected:
RGWOp *op_get() override;
RGWOp *op_head() override;
RGWOp *op_put() override;
RGWOp *op_post() override;
RGWOp *op_delete() override;
public:
using RGWHandler_REST_SWIFT::RGWHandler_REST_SWIFT;
~RGWHandler_REST_Service_SWIFT() override = default;
};
class RGWHandler_REST_Bucket_SWIFT : public RGWHandler_REST_SWIFT {
/* We need the boost::optional here only because of handler's late
* initialization (see the init() method). */
boost::optional<RGWSwiftWebsiteHandler> website_handler;
protected:
bool is_obj_update_op() const override {
return s->op == OP_POST;
}
RGWOp *get_obj_op(bool get_data);
RGWOp *op_get() override;
RGWOp *op_head() override;
RGWOp *op_put() override;
RGWOp *op_delete() override;
RGWOp *op_post() override;
RGWOp *op_options() override;
public:
using RGWHandler_REST_SWIFT::RGWHandler_REST_SWIFT;
~RGWHandler_REST_Bucket_SWIFT() override = default;
int error_handler(int err_no, std::string *error_content, optional_yield y) override {
return website_handler->error_handler(err_no, error_content, y);
}
int retarget(RGWOp* op, RGWOp** new_op, optional_yield) override {
return website_handler->retarget_bucket(op, new_op);
}
int init(rgw::sal::Driver* const driver,
req_state* const s,
rgw::io::BasicClient* const cio) override {
website_handler = boost::in_place<RGWSwiftWebsiteHandler>(driver, s, this);
return RGWHandler_REST_SWIFT::init(driver, s, cio);
}
};
class RGWHandler_REST_Obj_SWIFT : public RGWHandler_REST_SWIFT {
/* We need the boost::optional here only because of handler's late
* initialization (see the init() method). */
boost::optional<RGWSwiftWebsiteHandler> website_handler;
protected:
bool is_obj_update_op() const override {
return s->op == OP_POST;
}
RGWOp *get_obj_op(bool get_data);
RGWOp *op_get() override;
RGWOp *op_head() override;
RGWOp *op_put() override;
RGWOp *op_delete() override;
RGWOp *op_post() override;
RGWOp *op_copy() override;
RGWOp *op_options() override;
public:
using RGWHandler_REST_SWIFT::RGWHandler_REST_SWIFT;
~RGWHandler_REST_Obj_SWIFT() override = default;
int error_handler(int err_no, std::string *error_content,
optional_yield y) override {
return website_handler->error_handler(err_no, error_content, y);
}
int retarget(RGWOp* op, RGWOp** new_op, optional_yield) override {
return website_handler->retarget_object(op, new_op);
}
int init(rgw::sal::Driver* const driver,
req_state* const s,
rgw::io::BasicClient* const cio) override {
website_handler = boost::in_place<RGWSwiftWebsiteHandler>(driver, s, this);
return RGWHandler_REST_SWIFT::init(driver, s, cio);
}
};
class RGWRESTMgr_SWIFT : public RGWRESTMgr {
protected:
RGWRESTMgr* get_resource_mgr_as_default(req_state* const s,
const std::string& uri,
std::string* const out_uri) override {
return this->get_resource_mgr(s, uri, out_uri);
}
public:
RGWRESTMgr_SWIFT() = default;
~RGWRESTMgr_SWIFT() override = default;
RGWHandler_REST *get_handler(rgw::sal::Driver* driver,
req_state *s,
const rgw::auth::StrategyRegistry& auth_registry,
const std::string& frontend_prefix) override;
};
class RGWGetCrossDomainPolicy_ObjStore_SWIFT
: public RGWGetCrossDomainPolicy_ObjStore {
public:
RGWGetCrossDomainPolicy_ObjStore_SWIFT() = default;
~RGWGetCrossDomainPolicy_ObjStore_SWIFT() override = default;
void send_response() override;
};
class RGWGetHealthCheck_ObjStore_SWIFT
: public RGWGetHealthCheck_ObjStore {
public:
RGWGetHealthCheck_ObjStore_SWIFT() = default;
~RGWGetHealthCheck_ObjStore_SWIFT() override = default;
void send_response() override;
};
class RGWHandler_SWIFT_CrossDomain : public RGWHandler_REST {
public:
RGWHandler_SWIFT_CrossDomain() = default;
~RGWHandler_SWIFT_CrossDomain() override = default;
RGWOp *op_get() override {
return new RGWGetCrossDomainPolicy_ObjStore_SWIFT();
}
int init(rgw::sal::Driver* const driver,
req_state* const state,
rgw::io::BasicClient* const cio) override {
state->dialect = "swift";
state->formatter = new JSONFormatter;
state->format = RGWFormat::JSON;
return RGWHandler::init(driver, state, cio);
}
int authorize(const DoutPrefixProvider *dpp, optional_yield) override {
return 0;
}
int postauth_init(optional_yield) override {
return 0;
}
int read_permissions(RGWOp *, optional_yield y) override {
return 0;
}
virtual RGWAccessControlPolicy *alloc_policy() { return nullptr; }
virtual void free_policy(RGWAccessControlPolicy *policy) {}
};
class RGWRESTMgr_SWIFT_CrossDomain : public RGWRESTMgr {
protected:
RGWRESTMgr *get_resource_mgr(req_state* const s,
const std::string& uri,
std::string* const out_uri) override {
return this;
}
public:
RGWRESTMgr_SWIFT_CrossDomain() = default;
~RGWRESTMgr_SWIFT_CrossDomain() override = default;
RGWHandler_REST* get_handler(rgw::sal::Driver* driver,
req_state* const s,
const rgw::auth::StrategyRegistry&,
const std::string&) override {
s->prot_flags |= RGW_REST_SWIFT;
return new RGWHandler_SWIFT_CrossDomain;
}
};
class RGWHandler_SWIFT_HealthCheck : public RGWHandler_REST {
public:
RGWHandler_SWIFT_HealthCheck() = default;
~RGWHandler_SWIFT_HealthCheck() override = default;
RGWOp *op_get() override {
return new RGWGetHealthCheck_ObjStore_SWIFT();
}
int init(rgw::sal::Driver* const driver,
req_state* const state,
rgw::io::BasicClient* const cio) override {
state->dialect = "swift";
state->formatter = new JSONFormatter;
state->format = RGWFormat::JSON;
return RGWHandler::init(driver, state, cio);
}
int authorize(const DoutPrefixProvider *dpp, optional_yield y) override {
return 0;
}
int postauth_init(optional_yield) override {
return 0;
}
int read_permissions(RGWOp *, optional_yield y) override {
return 0;
}
virtual RGWAccessControlPolicy *alloc_policy() { return nullptr; }
virtual void free_policy(RGWAccessControlPolicy *policy) {}
};
class RGWRESTMgr_SWIFT_HealthCheck : public RGWRESTMgr {
protected:
RGWRESTMgr *get_resource_mgr(req_state* const s,
const std::string& uri,
std::string* const out_uri) override {
return this;
}
public:
RGWRESTMgr_SWIFT_HealthCheck() = default;
~RGWRESTMgr_SWIFT_HealthCheck() override = default;
RGWHandler_REST* get_handler(rgw::sal::Driver* driver,
req_state* const s,
const rgw::auth::StrategyRegistry&,
const std::string&) override {
s->prot_flags |= RGW_REST_SWIFT;
return new RGWHandler_SWIFT_HealthCheck;
}
};
class RGWHandler_REST_SWIFT_Info : public RGWHandler_REST_SWIFT {
public:
using RGWHandler_REST_SWIFT::RGWHandler_REST_SWIFT;
~RGWHandler_REST_SWIFT_Info() override = default;
RGWOp *op_get() override {
return new RGWInfo_ObjStore_SWIFT();
}
int init(rgw::sal::Driver* const driver,
req_state* const state,
rgw::io::BasicClient* const cio) override {
state->dialect = "swift";
state->formatter = new JSONFormatter;
state->format = RGWFormat::JSON;
return RGWHandler::init(driver, state, cio);
}
int authorize(const DoutPrefixProvider *dpp, optional_yield) override {
return 0;
}
int postauth_init(optional_yield) override {
return 0;
}
int read_permissions(RGWOp *, optional_yield y) override {
return 0;
}
};
class RGWRESTMgr_SWIFT_Info : public RGWRESTMgr {
public:
RGWRESTMgr_SWIFT_Info() = default;
~RGWRESTMgr_SWIFT_Info() override = default;
RGWHandler_REST *get_handler(rgw::sal::Driver* driver,
req_state* s,
const rgw::auth::StrategyRegistry& auth_registry,
const std::string& frontend_prefix) override;
};
| 20,185 | 28.425656 | 108 |
h
|
null |
ceph-main/src/rgw/rgw_rest_usage.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#include "rgw_op.h"
#include "rgw_usage.h"
#include "rgw_rest_usage.h"
#include "rgw_sal.h"
#include "include/str_list.h"
#define dout_subsys ceph_subsys_rgw
using namespace std;
class RGWOp_Usage_Get : public RGWRESTOp {
public:
RGWOp_Usage_Get() {}
int check_caps(const RGWUserCaps& caps) override {
return caps.check_cap("usage", RGW_CAP_READ);
}
void execute(optional_yield y) override;
const char* name() const override { return "get_usage"; }
};
void RGWOp_Usage_Get::execute(optional_yield y) {
map<std::string, bool> categories;
string uid_str;
string bucket_name;
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);
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()) {
driver->get_bucket(nullptr, user.get(), std::string(), bucket_name, &bucket, null_yield);
}
RESTArgs::get_epoch(s, "start", 0, &start);
RESTArgs::get_epoch(s, "end", (uint64_t)-1, &end);
RESTArgs::get_bool(s, "show-entries", true, &show_entries);
RESTArgs::get_bool(s, "show-summary", true, &show_summary);
string cat_str;
RESTArgs::get_string(s, "categories", cat_str, &cat_str);
if (!cat_str.empty()) {
list<string> cat_list;
list<string>::iterator iter;
get_str_list(cat_str, cat_list);
for (iter = cat_list.begin(); iter != cat_list.end(); ++iter) {
categories[*iter] = true;
}
}
op_ret = RGWUsage::show(this, driver, user.get(), bucket.get(), start, end, show_entries, show_summary, &categories, flusher);
}
class RGWOp_Usage_Delete : public RGWRESTOp {
public:
RGWOp_Usage_Delete() {}
int check_caps(const RGWUserCaps& caps) override {
return caps.check_cap("usage", RGW_CAP_WRITE);
}
void execute(optional_yield y) override;
const char* name() const override { return "trim_usage"; }
};
void RGWOp_Usage_Delete::execute(optional_yield y) {
string uid_str;
string bucket_name;
uint64_t start, end;
RESTArgs::get_string(s, "uid", uid_str, &uid_str);
RESTArgs::get_string(s, "bucket", bucket_name, &bucket_name);
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()) {
driver->get_bucket(nullptr, user.get(), std::string(), bucket_name, &bucket, null_yield);
}
RESTArgs::get_epoch(s, "start", 0, &start);
RESTArgs::get_epoch(s, "end", (uint64_t)-1, &end);
if (rgw::sal::User::empty(user.get()) &&
bucket_name.empty() &&
!start &&
end == (uint64_t)-1) {
bool remove_all;
RESTArgs::get_bool(s, "remove-all", false, &remove_all);
if (!remove_all) {
op_ret = -EINVAL;
return;
}
}
op_ret = RGWUsage::trim(this, driver, user.get(), bucket.get(), start, end, y);
}
RGWOp *RGWHandler_Usage::op_get()
{
return new RGWOp_Usage_Get;
}
RGWOp *RGWHandler_Usage::op_delete()
{
return new RGWOp_Usage_Delete;
}
| 3,198 | 25.221311 | 128 |
cc
|
null |
ceph-main/src/rgw/rgw_rest_usage.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#pragma once
#include "rgw_rest.h"
#include "rgw_rest_s3.h"
class RGWHandler_Usage : public RGWHandler_Auth_S3 {
protected:
RGWOp *op_get() override;
RGWOp *op_delete() override;
public:
using RGWHandler_Auth_S3::RGWHandler_Auth_S3;
~RGWHandler_Usage() override = default;
int read_permissions(RGWOp*, optional_yield) override {
return 0;
}
};
class RGWRESTMgr_Usage : public RGWRESTMgr {
public:
RGWRESTMgr_Usage() = default;
~RGWRESTMgr_Usage() override = default;
RGWHandler_REST* get_handler(rgw::sal::Driver* driver,
req_state*,
const rgw::auth::StrategyRegistry& auth_registry,
const std::string&) override {
return new RGWHandler_Usage(auth_registry);
}
};
| 876 | 24.057143 | 80 |
h
|
null |
ceph-main/src/rgw/rgw_rest_user_policy.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#include <errno.h>
#include <regex>
#include "common/errno.h"
#include "common/Formatter.h"
#include "common/ceph_json.h"
#include "include/types.h"
#include "rgw_string.h"
#include "rgw_common.h"
#include "rgw_op.h"
#include "rgw_rest.h"
#include "rgw_rest_user_policy.h"
#include "rgw_sal.h"
#include "services/svc_zone.h"
#define dout_subsys ceph_subsys_rgw
void RGWRestUserPolicy::dump(Formatter *f) const
{
encode_json("PolicyName", policy_name , f);
encode_json("UserName", user_name , f);
encode_json("PolicyDocument", policy, f);
}
void RGWRestUserPolicy::send_response()
{
if (op_ret) {
set_req_state_err(s, op_ret);
}
dump_errno(s);
end_header(s);
}
int RGWRestUserPolicy::verify_permission(optional_yield y)
{
if (s->auth.identity->is_anonymous()) {
return -EACCES;
}
if(int ret = check_caps(s->user->get_caps()); ret == 0) {
return ret;
}
uint64_t op = get_op();
std::string user_name = s->info.args.get("UserName");
rgw_user user_id(user_name);
if (! verify_user_permission(this, s, rgw::ARN(rgw::ARN(user_id.id,
"user",
user_id.tenant)), op)) {
return -EACCES;
}
return 0;
}
bool RGWRestUserPolicy::validate_input()
{
if (policy_name.length() > MAX_POLICY_NAME_LEN) {
ldpp_dout(this, 0) << "ERROR: Invalid policy name length " << dendl;
return false;
}
std::regex regex_policy_name("[A-Za-z0-9:=,.@-]+");
if (! std::regex_match(policy_name, regex_policy_name)) {
ldpp_dout(this, 0) << "ERROR: Invalid chars in policy name " << dendl;
return false;
}
return true;
}
int RGWUserPolicyRead::check_caps(const RGWUserCaps& caps)
{
return caps.check_cap("user-policy", RGW_CAP_READ);
}
int RGWUserPolicyWrite::check_caps(const RGWUserCaps& caps)
{
return caps.check_cap("user-policy", RGW_CAP_WRITE);
}
uint64_t RGWPutUserPolicy::get_op()
{
return rgw::IAM::iamPutUserPolicy;
}
int RGWPutUserPolicy::get_params()
{
policy_name = url_decode(s->info.args.get("PolicyName"), true);
user_name = url_decode(s->info.args.get("UserName"), true);
policy = url_decode(s->info.args.get("PolicyDocument"), true);
if (policy_name.empty() || user_name.empty() || policy.empty()) {
ldpp_dout(this, 20) << "ERROR: one of policy name, user name or policy document is empty"
<< dendl;
return -EINVAL;
}
if (! validate_input()) {
return -EINVAL;
}
return 0;
}
void RGWPutUserPolicy::execute(optional_yield y)
{
op_ret = get_params();
if (op_ret < 0) {
return;
}
bufferlist bl = bufferlist::static_from_string(policy);
std::unique_ptr<rgw::sal::User> user = driver->get_user(rgw_user(user_name));
op_ret = user->load_user(s, s->yield);
if (op_ret < 0) {
op_ret = -ERR_NO_SUCH_ENTITY;
return;
}
op_ret = user->read_attrs(s, s->yield);
if (op_ret == -ENOENT) {
op_ret = -ERR_NO_SUCH_ENTITY;
return;
}
ceph::bufferlist in_data;
op_ret = driver->forward_request_to_master(this, s->user.get(), nullptr, in_data, nullptr, s->info, y);
if (op_ret < 0) {
ldpp_dout(this, 0) << "ERROR: forward_request_to_master returned ret=" << op_ret << dendl;
return;
}
try {
const rgw::IAM::Policy p(
s->cct, s->user->get_tenant(), bl,
s->cct->_conf.get_val<bool>("rgw_policy_reject_invalid_principals"));
std::map<std::string, std::string> policies;
if (auto it = user->get_attrs().find(RGW_ATTR_USER_POLICY); it != user->get_attrs().end()) {
bufferlist out_bl = it->second;
decode(policies, out_bl);
}
bufferlist in_bl;
policies[policy_name] = policy;
constexpr unsigned int USER_POLICIES_MAX_NUM = 100;
const unsigned int max_num = s->cct->_conf->rgw_user_policies_max_num < 0 ?
USER_POLICIES_MAX_NUM : s->cct->_conf->rgw_user_policies_max_num;
if (policies.size() > max_num) {
ldpp_dout(this, 4) << "IAM user policies has reached the num config: "
<< max_num << ", cant add another" << dendl;
op_ret = -ERR_INVALID_REQUEST;
s->err.message =
"The number of IAM user policies should not exceed allowed limit "
"of " +
std::to_string(max_num) + " policies.";
return;
}
encode(policies, in_bl);
user->get_attrs()[RGW_ATTR_USER_POLICY] = in_bl;
op_ret = user->store_user(s, s->yield, false);
if (op_ret < 0) {
op_ret = -ERR_INTERNAL_ERROR;
}
} catch (buffer::error& err) {
ldpp_dout(this, 0) << "ERROR: failed to decode user policies" << dendl;
op_ret = -EIO;
} catch (rgw::IAM::PolicyParseException& e) {
ldpp_dout(this, 5) << "failed to parse policy: " << e.what() << dendl;
s->err.message = e.what();
op_ret = -ERR_MALFORMED_DOC;
}
if (op_ret == 0) {
s->formatter->open_object_section("PutUserPolicyResponse");
s->formatter->open_object_section("ResponseMetadata");
s->formatter->dump_string("RequestId", s->trans_id);
s->formatter->close_section();
s->formatter->close_section();
}
}
uint64_t RGWGetUserPolicy::get_op()
{
return rgw::IAM::iamGetUserPolicy;
}
int RGWGetUserPolicy::get_params()
{
policy_name = s->info.args.get("PolicyName");
user_name = s->info.args.get("UserName");
if (policy_name.empty() || user_name.empty()) {
ldpp_dout(this, 20) << "ERROR: one of policy name or user name is empty"
<< dendl;
return -EINVAL;
}
return 0;
}
void RGWGetUserPolicy::execute(optional_yield y)
{
op_ret = get_params();
if (op_ret < 0) {
return;
}
std::unique_ptr<rgw::sal::User> user = driver->get_user(rgw_user(user_name));
op_ret = user->read_attrs(s, s->yield);
if (op_ret == -ENOENT) {
ldpp_dout(this, 0) << "ERROR: attrs not found for user" << user_name << dendl;
op_ret = -ERR_NO_SUCH_ENTITY;
return;
}
if (op_ret == 0) {
s->formatter->open_object_section("GetUserPolicyResponse");
s->formatter->open_object_section("ResponseMetadata");
s->formatter->dump_string("RequestId", s->trans_id);
s->formatter->close_section();
s->formatter->open_object_section("GetUserPolicyResult");
std::map<std::string, std::string> policies;
if (auto it = user->get_attrs().find(RGW_ATTR_USER_POLICY); it != user->get_attrs().end()) {
bufferlist bl = it->second;
try {
decode(policies, bl);
} catch (buffer::error& err) {
ldpp_dout(this, 0) << "ERROR: failed to decode user policies" << dendl;
op_ret = -EIO;
return;
}
if (auto it = policies.find(policy_name); it != policies.end()) {
policy = policies[policy_name];
dump(s->formatter);
} else {
ldpp_dout(this, 0) << "ERROR: policy not found" << policy << dendl;
op_ret = -ERR_NO_SUCH_ENTITY;
return;
}
} else {
ldpp_dout(this, 0) << "ERROR: RGW_ATTR_USER_POLICY not found" << dendl;
op_ret = -ERR_NO_SUCH_ENTITY;
return;
}
s->formatter->close_section();
s->formatter->close_section();
}
if (op_ret < 0) {
op_ret = -ERR_INTERNAL_ERROR;
}
}
uint64_t RGWListUserPolicies::get_op()
{
return rgw::IAM::iamListUserPolicies;
}
int RGWListUserPolicies::get_params()
{
user_name = s->info.args.get("UserName");
if (user_name.empty()) {
ldpp_dout(this, 20) << "ERROR: user name is empty" << dendl;
return -EINVAL;
}
return 0;
}
void RGWListUserPolicies::execute(optional_yield y)
{
op_ret = get_params();
if (op_ret < 0) {
return;
}
std::unique_ptr<rgw::sal::User> user = driver->get_user(rgw_user(user_name));
op_ret = user->read_attrs(s, s->yield);
if (op_ret == -ENOENT) {
ldpp_dout(this, 0) << "ERROR: attrs not found for user" << user_name << dendl;
op_ret = -ERR_NO_SUCH_ENTITY;
return;
}
if (op_ret == 0) {
std::map<std::string, std::string> policies;
if (auto it = user->get_attrs().find(RGW_ATTR_USER_POLICY); it != user->get_attrs().end()) {
s->formatter->open_object_section("ListUserPoliciesResponse");
s->formatter->open_object_section("ResponseMetadata");
s->formatter->dump_string("RequestId", s->trans_id);
s->formatter->close_section();
s->formatter->open_object_section("ListUserPoliciesResult");
bufferlist bl = it->second;
try {
decode(policies, bl);
} catch (buffer::error& err) {
ldpp_dout(this, 0) << "ERROR: failed to decode user policies" << dendl;
op_ret = -EIO;
return;
}
s->formatter->open_object_section("PolicyNames");
for (const auto& p : policies) {
s->formatter->dump_string("member", p.first);
}
s->formatter->close_section();
s->formatter->close_section();
s->formatter->close_section();
} else {
ldpp_dout(this, 0) << "ERROR: RGW_ATTR_USER_POLICY not found" << dendl;
op_ret = -ERR_NO_SUCH_ENTITY;
return;
}
}
if (op_ret < 0) {
op_ret = -ERR_INTERNAL_ERROR;
}
}
uint64_t RGWDeleteUserPolicy::get_op()
{
return rgw::IAM::iamDeleteUserPolicy;
}
int RGWDeleteUserPolicy::get_params()
{
policy_name = s->info.args.get("PolicyName");
user_name = s->info.args.get("UserName");
if (policy_name.empty() || user_name.empty()) {
ldpp_dout(this, 20) << "ERROR: One of policy name or user name is empty"<< dendl;
return -EINVAL;
}
return 0;
}
void RGWDeleteUserPolicy::execute(optional_yield y)
{
op_ret = get_params();
if (op_ret < 0) {
return;
}
std::unique_ptr<rgw::sal::User> user = driver->get_user(rgw_user(user_name));
op_ret = user->load_user(s, s->yield);
if (op_ret < 0) {
op_ret = -ERR_NO_SUCH_ENTITY;
return;
}
op_ret = user->read_attrs(this, s->yield);
if (op_ret == -ENOENT) {
op_ret = -ERR_NO_SUCH_ENTITY;
return;
}
ceph::bufferlist in_data;
op_ret = driver->forward_request_to_master(this, s->user.get(), nullptr, in_data, nullptr, s->info, y);
if (op_ret < 0) {
// a policy might've been uploaded to this site when there was no sync
// req. in earlier releases, proceed deletion
if (op_ret != -ENOENT) {
ldpp_dout(this, 5) << "forward_request_to_master returned ret=" << op_ret << dendl;
return;
}
ldpp_dout(this, 0) << "ERROR: forward_request_to_master returned ret=" << op_ret << dendl;
}
std::map<std::string, std::string> policies;
if (auto it = user->get_attrs().find(RGW_ATTR_USER_POLICY); it != user->get_attrs().end()) {
bufferlist out_bl = it->second;
try {
decode(policies, out_bl);
} catch (buffer::error& err) {
ldpp_dout(this, 0) << "ERROR: failed to decode user policies" << dendl;
op_ret = -EIO;
return;
}
if (auto p = policies.find(policy_name); p != policies.end()) {
bufferlist in_bl;
policies.erase(p);
encode(policies, in_bl);
user->get_attrs()[RGW_ATTR_USER_POLICY] = in_bl;
op_ret = user->store_user(s, s->yield, false);
if (op_ret < 0) {
op_ret = -ERR_INTERNAL_ERROR;
}
if (op_ret == 0) {
s->formatter->open_object_section("DeleteUserPoliciesResponse");
s->formatter->open_object_section("ResponseMetadata");
s->formatter->dump_string("RequestId", s->trans_id);
s->formatter->close_section();
s->formatter->close_section();
}
} else {
op_ret = -ERR_NO_SUCH_ENTITY;
return;
}
} else {
op_ret = -ERR_NO_SUCH_ENTITY;
return;
}
}
| 11,601 | 27.024155 | 105 |
cc
|
null |
ceph-main/src/rgw/rgw_rest_user_policy.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#pragma once
#include "rgw_rest.h"
class RGWRestUserPolicy : public RGWRESTOp {
protected:
static constexpr int MAX_POLICY_NAME_LEN = 128;
std::string policy_name;
std::string user_name;
std::string policy;
bool validate_input();
public:
int verify_permission(optional_yield y) override;
virtual uint64_t get_op() = 0;
void send_response() override;
void dump(Formatter *f) const;
};
class RGWUserPolicyRead : public RGWRestUserPolicy {
public:
RGWUserPolicyRead() = default;
int check_caps(const RGWUserCaps& caps) override;
};
class RGWUserPolicyWrite : public RGWRestUserPolicy {
public:
RGWUserPolicyWrite() = default;
int check_caps(const RGWUserCaps& caps) override;
};
class RGWPutUserPolicy : public RGWUserPolicyWrite {
public:
RGWPutUserPolicy() = default;
void execute(optional_yield y) override;
int get_params();
const char* name() const override { return "put_user-policy"; }
uint64_t get_op() override;
RGWOpType get_type() override { return RGW_OP_PUT_USER_POLICY; }
};
class RGWGetUserPolicy : public RGWUserPolicyRead {
public:
RGWGetUserPolicy() = default;
void execute(optional_yield y) override;
int get_params();
const char* name() const override { return "get_user_policy"; }
uint64_t get_op() override;
RGWOpType get_type() override { return RGW_OP_GET_USER_POLICY; }
};
class RGWListUserPolicies : public RGWUserPolicyRead {
public:
RGWListUserPolicies() = default;
void execute(optional_yield y) override;
int get_params();
const char* name() const override { return "list_user_policies"; }
uint64_t get_op() override;
RGWOpType get_type() override { return RGW_OP_LIST_USER_POLICIES; }
};
class RGWDeleteUserPolicy : public RGWUserPolicyWrite {
public:
RGWDeleteUserPolicy() = default;
void execute(optional_yield y) override;
int get_params();
const char* name() const override { return "delete_user_policy"; }
uint64_t get_op() override;
RGWOpType get_type() override { return RGW_OP_DELETE_USER_POLICY; }
};
| 2,127 | 27.756757 | 70 |
h
|
null |
ceph-main/src/rgw/rgw_rest_zero.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "rgw_rest_zero.h"
#include <mutex>
#include <vector>
#include "common/strtol.h"
namespace rgw {
// all paths refer to a single resource that contains only a size
class ZeroResource {
public:
std::mutex mutex;
std::size_t size = 0;
};
// base op
class ZeroOp : public RGWOp {
protected:
ZeroResource* const resource;
const char* response_content_type = nullptr;
int64_t response_content_length = NO_CONTENT_LENGTH;
public:
explicit ZeroOp(ZeroResource* resource) : resource(resource) {}
int verify_permission(optional_yield y) override { return 0; }
void send_response() override;
};
void ZeroOp::send_response()
{
if (op_ret) {
set_req_state_err(s, op_ret);
}
dump_errno(s);
end_header(s, this, response_content_type, response_content_length);
}
// DELETE op resets resource size to 0
class ZeroDeleteOp : public ZeroOp {
public:
explicit ZeroDeleteOp(ZeroResource* resource) : ZeroOp(resource) {}
const char* name() const override { return "zero_delete"; }
void execute(optional_yield y) override;
};
void ZeroDeleteOp::execute(optional_yield y)
{
auto lock = std::scoped_lock(resource->mutex);
resource->size = 0;
}
// GET op returns a request body of all zeroes
class ZeroGetOp : public ZeroOp {
public:
explicit ZeroGetOp(ZeroResource* resource) : ZeroOp(resource) {}
const char* name() const override { return "zero_get"; }
void execute(optional_yield y) override;
void send_response() override;
};
void ZeroGetOp::execute(optional_yield y)
{
response_content_type = "application/octet-stream";
auto lock = std::scoped_lock(resource->mutex);
response_content_length = resource->size;
}
void ZeroGetOp::send_response()
{
// send the response header
ZeroOp::send_response();
// write zeroes for the entire response body
size_t remaining = static_cast<size_t>(response_content_length);
const size_t chunk_size = s->cct->_conf->rgw_max_chunk_size;
std::vector<char> zeroes;
zeroes.resize(std::min(remaining, chunk_size), '\0');
try {
while (remaining) {
const size_t count = std::min(zeroes.size(), remaining);
const int bytes = dump_body(s, zeroes.data(), count);
remaining -= bytes;
}
} catch (const std::exception& e) {
ldpp_dout(this, 0) << "recv_body failed with " << e.what() << dendl;
op_ret = -EIO;
return;
}
}
// HEAD op returns the current content length
class ZeroHeadOp : public ZeroOp {
public:
explicit ZeroHeadOp(ZeroResource* resource) : ZeroOp(resource) {}
const char* name() const override { return "zero_head"; }
void execute(optional_yield y) override;
};
void ZeroHeadOp::execute(optional_yield y)
{
response_content_type = "application/octet-stream";
auto lock = std::scoped_lock(resource->mutex);
response_content_length = resource->size;
}
// PUT op discards the entire request body then updates the content length
class ZeroPutOp : public ZeroOp {
public:
explicit ZeroPutOp(ZeroResource* resource) : ZeroOp(resource) {}
const char* name() const override { return "zero_put"; }
void execute(optional_yield y) override;
};
void ZeroPutOp::execute(optional_yield y)
{
if (!s->length) {
ldpp_dout(this, 0) << "missing content length" << dendl;
op_ret = -ERR_LENGTH_REQUIRED;
return;
}
const auto content_length = ceph::parse<size_t>(s->length);
if (!content_length) {
ldpp_dout(this, 0) << "failed to parse content length \""
<< s->length << '"' << dendl;
op_ret = -EINVAL;
return;
}
// read and discard the entire request body
size_t remaining = *content_length;
const size_t chunk_size = s->cct->_conf->rgw_max_chunk_size;
std::vector<char> buffer;
buffer.resize(std::min(remaining, chunk_size));
try {
while (remaining) {
const size_t count = std::min(buffer.size(), remaining);
const int bytes = recv_body(s, buffer.data(), count);
remaining -= bytes;
}
} catch (const std::exception& e) {
ldpp_dout(this, 0) << "recv_body failed with " << e.what() << dendl;
op_ret = -EIO;
return;
}
// on success, update the resource size
auto lock = std::scoped_lock(resource->mutex);
resource->size = *content_length;
}
class ZeroHandler : public RGWHandler_REST {
ZeroResource* const resource;
public:
explicit ZeroHandler(ZeroResource* resource) : resource(resource) {}
int init_permissions(RGWOp*, optional_yield) override { return 0; }
int read_permissions(RGWOp*, optional_yield) override { return 0; }
int authorize(const DoutPrefixProvider* dpp, optional_yield y) override { return 0; }
int postauth_init(optional_yield y) override { return 0; }
// op factory functions
RGWOp* op_delete() override { return new ZeroDeleteOp(resource); }
RGWOp* op_get() override { return new ZeroGetOp(resource); }
RGWOp* op_head() override { return new ZeroHeadOp(resource); }
RGWOp* op_put() override { return new ZeroPutOp(resource); }
};
RESTMgr_Zero::RESTMgr_Zero() : resource(std::make_unique<ZeroResource>()) {}
RGWHandler_REST* RESTMgr_Zero::get_handler(sal::Driver* driver, req_state* s,
const auth::StrategyRegistry& auth,
const std::string& prefix)
{
return new ZeroHandler(resource.get());
}
} // namespace rgw
| 5,689 | 27.592965 | 87 |
cc
|
null |
ceph-main/src/rgw/rgw_rest_zero.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#pragma once
#include <memory>
#include "rgw_rest.h"
namespace rgw {
class ZeroResource;
// a rest endpoint that's only useful for benchmarking the http frontend.
// requests are not authenticated, and do no reads/writes to the backend
class RESTMgr_Zero : public RGWRESTMgr {
std::unique_ptr<ZeroResource> resource;
public:
RESTMgr_Zero();
RGWHandler_REST* get_handler(sal::Driver* driver, req_state* s,
const auth::StrategyRegistry& auth,
const std::string& prefix) override;
};
} // namespace rgw
| 947 | 26.085714 | 73 |
h
|
null |
ceph-main/src/rgw/rgw_role.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#include <errno.h>
#include <ctime>
#include <regex>
#include <boost/algorithm/string/replace.hpp>
#include "common/errno.h"
#include "common/Formatter.h"
#include "common/ceph_json.h"
#include "common/ceph_time.h"
#include "rgw_rados.h"
#include "rgw_zone.h"
#include "include/types.h"
#include "rgw_string.h"
#include "rgw_common.h"
#include "rgw_tools.h"
#include "rgw_role.h"
#include "services/svc_zone.h"
#include "services/svc_sys_obj.h"
#include "services/svc_meta_be_sobj.h"
#include "services/svc_meta.h"
#include "services/svc_role_rados.h"
#define dout_subsys ceph_subsys_rgw
using namespace std;
namespace rgw { namespace sal {
const string RGWRole::role_name_oid_prefix = "role_names.";
const string RGWRole::role_oid_prefix = "roles.";
const string RGWRole::role_path_oid_prefix = "role_paths.";
const string RGWRole::role_arn_prefix = "arn:aws:iam::";
void RGWRoleInfo::dump(Formatter *f) const
{
encode_json("RoleId", id , f);
std::string role_name;
if (tenant.empty()) {
role_name = name;
} else {
role_name = tenant + '$' + name;
}
encode_json("RoleName", role_name , f);
encode_json("Path", path, f);
encode_json("Arn", arn, f);
encode_json("CreateDate", creation_date, f);
encode_json("MaxSessionDuration", max_session_duration, f);
encode_json("AssumeRolePolicyDocument", trust_policy, f);
if (!perm_policy_map.empty()) {
f->open_array_section("PermissionPolicies");
for (const auto& it : perm_policy_map) {
f->open_object_section("Policy");
encode_json("PolicyName", it.first, f);
encode_json("PolicyValue", it.second, f);
f->close_section();
}
f->close_section();
}
if (!tags.empty()) {
f->open_array_section("Tags");
for (const auto& it : tags) {
f->open_object_section("Tag");
encode_json("Key", it.first, f);
encode_json("Value", it.second, f);
f->close_section();
}
f->close_section();
}
}
void RGWRoleInfo::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("RoleId", id, obj);
JSONDecoder::decode_json("RoleName", name, obj);
JSONDecoder::decode_json("Path", path, obj);
JSONDecoder::decode_json("Arn", arn, obj);
JSONDecoder::decode_json("CreateDate", creation_date, obj);
JSONDecoder::decode_json("MaxSessionDuration", max_session_duration, obj);
JSONDecoder::decode_json("AssumeRolePolicyDocument", trust_policy, obj);
auto tags_iter = obj->find_first("Tags");
if (!tags_iter.end()) {
JSONObj* tags_json = *tags_iter;
auto iter = tags_json->find_first();
for (; !iter.end(); ++iter) {
std::string key, val;
JSONDecoder::decode_json("Key", key, *iter);
JSONDecoder::decode_json("Value", val, *iter);
this->tags.emplace(key, val);
}
}
auto perm_policy_iter = obj->find_first("PermissionPolicies");
if (!perm_policy_iter.end()) {
JSONObj* perm_policies = *perm_policy_iter;
auto iter = perm_policies->find_first();
for (; !iter.end(); ++iter) {
std::string policy_name, policy_val;
JSONDecoder::decode_json("PolicyName", policy_name, *iter);
JSONDecoder::decode_json("PolicyValue", policy_val, *iter);
this->perm_policy_map.emplace(policy_name, policy_val);
}
}
if (auto pos = name.find('$'); pos != std::string::npos) {
tenant = name.substr(0, pos);
name = name.substr(pos+1);
}
}
RGWRole::RGWRole(std::string name,
std::string tenant,
std::string path,
std::string trust_policy,
std::string max_session_duration_str,
std::multimap<std::string,std::string> tags)
{
info.name = std::move(name);
info.path = std::move(path);
info.trust_policy = std::move(trust_policy);
info.tenant = std::move(tenant);
info.tags = std::move(tags);
if (this->info.path.empty())
this->info.path = "/";
extract_name_tenant(this->info.name);
if (max_session_duration_str.empty()) {
info.max_session_duration = SESSION_DURATION_MIN;
} else {
info.max_session_duration = std::stoull(max_session_duration_str);
}
info.mtime = real_time();
}
RGWRole::RGWRole(std::string id)
{
info.id = std::move(id);
}
int RGWRole::get(const DoutPrefixProvider *dpp, optional_yield y)
{
int ret = read_name(dpp, y);
if (ret < 0) {
return ret;
}
ret = read_info(dpp, y);
if (ret < 0) {
return ret;
}
return 0;
}
int RGWRole::get_by_id(const DoutPrefixProvider *dpp, optional_yield y)
{
int ret = read_info(dpp, y);
if (ret < 0) {
return ret;
}
return 0;
}
void RGWRole::dump(Formatter *f) const
{
info.dump(f);
}
void RGWRole::decode_json(JSONObj *obj)
{
info.decode_json(obj);
}
bool RGWRole::validate_max_session_duration(const DoutPrefixProvider* dpp)
{
if (info.max_session_duration < SESSION_DURATION_MIN ||
info.max_session_duration > SESSION_DURATION_MAX) {
ldpp_dout(dpp, 0) << "ERROR: Invalid session duration, should be between 3600 and 43200 seconds " << dendl;
return false;
}
return true;
}
bool RGWRole::validate_input(const DoutPrefixProvider* dpp)
{
if (info.name.length() > MAX_ROLE_NAME_LEN) {
ldpp_dout(dpp, 0) << "ERROR: Invalid name length " << dendl;
return false;
}
if (info.path.length() > MAX_PATH_NAME_LEN) {
ldpp_dout(dpp, 0) << "ERROR: Invalid path length " << dendl;
return false;
}
std::regex regex_name("[A-Za-z0-9:=,.@-]+");
if (! std::regex_match(info.name, regex_name)) {
ldpp_dout(dpp, 0) << "ERROR: Invalid chars in name " << dendl;
return false;
}
std::regex regex_path("(/[!-~]+/)|(/)");
if (! std::regex_match(info.path,regex_path)) {
ldpp_dout(dpp, 0) << "ERROR: Invalid chars in path " << dendl;
return false;
}
if (!validate_max_session_duration(dpp)) {
return false;
}
return true;
}
void RGWRole::extract_name_tenant(const std::string& str) {
if (auto pos = str.find('$');
pos != std::string::npos) {
info.tenant = str.substr(0, pos);
info.name = str.substr(pos+1);
}
}
int RGWRole::update(const DoutPrefixProvider *dpp, optional_yield y)
{
int ret = store_info(dpp, false, y);
if (ret < 0) {
ldpp_dout(dpp, 0) << "ERROR: storing info in Role pool: "
<< info.id << ": " << cpp_strerror(-ret) << dendl;
return ret;
}
return 0;
}
void RGWRole::set_perm_policy(const string& policy_name, const string& perm_policy)
{
info.perm_policy_map[policy_name] = perm_policy;
}
vector<string> RGWRole::get_role_policy_names()
{
vector<string> policy_names;
for (const auto& it : info.perm_policy_map)
{
policy_names.push_back(std::move(it.first));
}
return policy_names;
}
int RGWRole::get_role_policy(const DoutPrefixProvider* dpp, const string& policy_name, string& perm_policy)
{
const auto it = info.perm_policy_map.find(policy_name);
if (it == info.perm_policy_map.end()) {
ldpp_dout(dpp, 0) << "ERROR: Policy name: " << policy_name << " not found" << dendl;
return -ENOENT;
} else {
perm_policy = it->second;
}
return 0;
}
int RGWRole::delete_policy(const DoutPrefixProvider* dpp, const string& policy_name)
{
const auto& it = info.perm_policy_map.find(policy_name);
if (it == info.perm_policy_map.end()) {
ldpp_dout(dpp, 0) << "ERROR: Policy name: " << policy_name << " not found" << dendl;
return -ENOENT;
} else {
info.perm_policy_map.erase(it);
}
return 0;
}
void RGWRole::update_trust_policy(string& trust_policy)
{
this->info.trust_policy = trust_policy;
}
int RGWRole::set_tags(const DoutPrefixProvider* dpp, const multimap<string,string>& tags_map)
{
for (auto& it : tags_map) {
this->info.tags.emplace(it.first, it.second);
}
if (this->info.tags.size() > 50) {
ldpp_dout(dpp, 0) << "No. of tags is greater than 50" << dendl;
return -EINVAL;
}
return 0;
}
boost::optional<multimap<string,string>> RGWRole::get_tags()
{
if(this->info.tags.empty()) {
return boost::none;
}
return this->info.tags;
}
void RGWRole::erase_tags(const vector<string>& tagKeys)
{
for (auto& it : tagKeys) {
this->info.tags.erase(it);
}
}
void RGWRole::update_max_session_duration(const std::string& max_session_duration_str)
{
if (max_session_duration_str.empty()) {
info.max_session_duration = SESSION_DURATION_MIN;
} else {
info.max_session_duration = std::stoull(max_session_duration_str);
}
}
const string& RGWRole::get_names_oid_prefix()
{
return role_name_oid_prefix;
}
const string& RGWRole::get_info_oid_prefix()
{
return role_oid_prefix;
}
const string& RGWRole::get_path_oid_prefix()
{
return role_path_oid_prefix;
}
RGWRoleMetadataHandler::RGWRoleMetadataHandler(Driver* driver,
RGWSI_Role_RADOS *role_svc)
{
this->driver = driver;
base_init(role_svc->ctx(), role_svc->get_be_handler());
}
RGWMetadataObject *RGWRoleMetadataHandler::get_meta_obj(JSONObj *jo,
const obj_version& objv,
const ceph::real_time& mtime)
{
RGWRoleInfo info;
try {
info.decode_json(jo);
} catch (JSONDecoder:: err& e) {
return nullptr;
}
return new RGWRoleMetadataObject(info, objv, mtime, driver);
}
int RGWRoleMetadataHandler::do_get(RGWSI_MetaBackend_Handler::Op *op,
std::string& entry,
RGWMetadataObject **obj,
optional_yield y,
const DoutPrefixProvider *dpp)
{
std::unique_ptr<rgw::sal::RGWRole> role = driver->get_role(entry);
int ret = role->read_info(dpp, y);
if (ret < 0) {
return ret;
}
RGWObjVersionTracker objv_tracker = role->get_objv_tracker();
real_time mtime = role->get_mtime();
RGWRoleInfo info = role->get_info();
RGWRoleMetadataObject *rdo = new RGWRoleMetadataObject(info, objv_tracker.read_version,
mtime, driver);
*obj = rdo;
return 0;
}
int RGWRoleMetadataHandler::do_remove(RGWSI_MetaBackend_Handler::Op *op,
std::string& entry,
RGWObjVersionTracker& objv_tracker,
optional_yield y,
const DoutPrefixProvider *dpp)
{
std::unique_ptr<rgw::sal::RGWRole> role = driver->get_role(entry);
int ret = role->read_info(dpp, y);
if (ret < 0) {
return ret == -ENOENT? 0 : ret;
}
return role->delete_obj(dpp, y);
}
class RGWMetadataHandlerPut_Role : public RGWMetadataHandlerPut_SObj
{
RGWRoleMetadataHandler *rhandler;
RGWRoleMetadataObject *mdo;
public:
RGWMetadataHandlerPut_Role(RGWRoleMetadataHandler *handler,
RGWSI_MetaBackend_Handler::Op *op,
std::string& entry,
RGWMetadataObject *obj,
RGWObjVersionTracker& objv_tracker,
optional_yield y,
RGWMDLogSyncType type,
bool from_remote_zone) :
RGWMetadataHandlerPut_SObj(handler, op, entry, obj, objv_tracker, y, type, from_remote_zone),
rhandler(handler) {
mdo = static_cast<RGWRoleMetadataObject*>(obj);
}
int put_checked(const DoutPrefixProvider *dpp) override {
auto& info = mdo->get_role_info();
auto mtime = mdo->get_mtime();
auto* driver = mdo->get_driver();
info.mtime = mtime;
std::unique_ptr<rgw::sal::RGWRole> role = driver->get_role(info);
int ret = role->create(dpp, true, info.id, y);
if (ret == -EEXIST) {
ret = role->update(dpp, y);
}
return ret < 0 ? ret : STATUS_APPLIED;
}
};
int RGWRoleMetadataHandler::do_put(RGWSI_MetaBackend_Handler::Op *op,
std::string& entry,
RGWMetadataObject *obj,
RGWObjVersionTracker& objv_tracker,
optional_yield y,
const DoutPrefixProvider *dpp,
RGWMDLogSyncType type,
bool from_remote_zone)
{
RGWMetadataHandlerPut_Role put_op(this, op , entry, obj, objv_tracker, y, type, from_remote_zone);
return do_put_operate(&put_op, dpp);
}
} } // namespace rgw::sal
| 12,464 | 27.011236 | 111 |
cc
|
null |
ceph-main/src/rgw/rgw_role.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#pragma once
#include <string>
#include "common/async/yield_context.h"
#include "common/ceph_json.h"
#include "common/ceph_context.h"
#include "rgw_rados.h"
#include "rgw_metadata.h"
class RGWRados;
namespace rgw { namespace sal {
struct RGWRoleInfo
{
std::string id;
std::string name;
std::string path;
std::string arn;
std::string creation_date;
std::string trust_policy;
std::map<std::string, std::string> perm_policy_map;
std::string tenant;
uint64_t max_session_duration;
std::multimap<std::string,std::string> tags;
std::map<std::string, bufferlist> attrs;
RGWObjVersionTracker objv_tracker;
real_time mtime;
RGWRoleInfo() = default;
~RGWRoleInfo() = default;
void encode(bufferlist& bl) const {
ENCODE_START(3, 1, bl);
encode(id, bl);
encode(name, bl);
encode(path, bl);
encode(arn, bl);
encode(creation_date, bl);
encode(trust_policy, bl);
encode(perm_policy_map, bl);
encode(tenant, bl);
encode(max_session_duration, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(3, bl);
decode(id, bl);
decode(name, bl);
decode(path, bl);
decode(arn, bl);
decode(creation_date, bl);
decode(trust_policy, bl);
decode(perm_policy_map, bl);
if (struct_v >= 2) {
decode(tenant, bl);
}
if (struct_v >= 3) {
decode(max_session_duration, bl);
}
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
};
WRITE_CLASS_ENCODER(RGWRoleInfo)
class RGWRole
{
public:
static const std::string role_name_oid_prefix;
static const std::string role_oid_prefix;
static const std::string role_path_oid_prefix;
static const std::string role_arn_prefix;
static constexpr int MAX_ROLE_NAME_LEN = 64;
static constexpr int MAX_PATH_NAME_LEN = 512;
static constexpr uint64_t SESSION_DURATION_MIN = 3600; // in seconds
static constexpr uint64_t SESSION_DURATION_MAX = 43200; // in seconds
protected:
RGWRoleInfo info;
public:
virtual int store_info(const DoutPrefixProvider *dpp, bool exclusive, optional_yield y) = 0;
virtual int store_name(const DoutPrefixProvider *dpp, bool exclusive, optional_yield y) = 0;
virtual int store_path(const DoutPrefixProvider *dpp, bool exclusive, optional_yield y) = 0;
virtual int read_id(const DoutPrefixProvider *dpp, const std::string& role_name, const std::string& tenant, std::string& role_id, optional_yield y) = 0;
virtual int read_name(const DoutPrefixProvider *dpp, optional_yield y) = 0;
virtual int read_info(const DoutPrefixProvider *dpp, optional_yield y) = 0;
bool validate_max_session_duration(const DoutPrefixProvider* dpp);
bool validate_input(const DoutPrefixProvider* dpp);
void extract_name_tenant(const std::string& str);
RGWRole(std::string name,
std::string tenant,
std::string path="",
std::string trust_policy="",
std::string max_session_duration_str="",
std::multimap<std::string,std::string> tags={});
explicit RGWRole(std::string id);
explicit RGWRole(const RGWRoleInfo& info) : info(info) {}
RGWRole() = default;
virtual ~RGWRole() = default;
const std::string& get_id() const { return info.id; }
const std::string& get_name() const { return info.name; }
const std::string& get_tenant() const { return info.tenant; }
const std::string& get_path() const { return info.path; }
const std::string& get_create_date() const { return info.creation_date; }
const std::string& get_assume_role_policy() const { return info.trust_policy;}
const uint64_t& get_max_session_duration() const { return info.max_session_duration; }
const RGWObjVersionTracker& get_objv_tracker() const { return info.objv_tracker; }
const real_time& get_mtime() const { return info.mtime; }
std::map<std::string, bufferlist>& get_attrs() { return info.attrs; }
RGWRoleInfo& get_info() { return info; }
void set_id(const std::string& id) { this->info.id = id; }
void set_mtime(const real_time& mtime) { this->info.mtime = mtime; }
virtual int create(const DoutPrefixProvider *dpp, bool exclusive, const std::string &role_id, optional_yield y) = 0;
virtual int delete_obj(const DoutPrefixProvider *dpp, optional_yield y) = 0;
int get(const DoutPrefixProvider *dpp, optional_yield y);
int get_by_id(const DoutPrefixProvider *dpp, optional_yield y);
int update(const DoutPrefixProvider *dpp, optional_yield y);
void update_trust_policy(std::string& trust_policy);
void set_perm_policy(const std::string& policy_name, const std::string& perm_policy);
std::vector<std::string> get_role_policy_names();
int get_role_policy(const DoutPrefixProvider* dpp, const std::string& policy_name, std::string& perm_policy);
int delete_policy(const DoutPrefixProvider* dpp, const std::string& policy_name);
int set_tags(const DoutPrefixProvider* dpp, const std::multimap<std::string,std::string>& tags_map);
boost::optional<std::multimap<std::string,std::string>> get_tags();
void erase_tags(const std::vector<std::string>& tagKeys);
void update_max_session_duration(const std::string& max_session_duration_str);
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
static const std::string& get_names_oid_prefix();
static const std::string& get_info_oid_prefix();
static const std::string& get_path_oid_prefix();
};
class RGWRoleMetadataObject: public RGWMetadataObject {
RGWRoleInfo info;
Driver* driver;
public:
RGWRoleMetadataObject() = default;
RGWRoleMetadataObject(RGWRoleInfo& info,
const obj_version& v,
real_time m,
Driver* driver) : RGWMetadataObject(v,m), info(info), driver(driver) {}
void dump(Formatter *f) const override {
info.dump(f);
}
RGWRoleInfo& get_role_info() {
return info;
}
Driver* get_driver() {
return driver;
}
};
class RGWRoleMetadataHandler: public RGWMetadataHandler_GenericMetaBE
{
public:
RGWRoleMetadataHandler(Driver* driver, RGWSI_Role_RADOS *role_svc);
std::string get_type() final { return "roles"; }
RGWMetadataObject *get_meta_obj(JSONObj *jo,
const obj_version& objv,
const ceph::real_time& mtime);
int do_get(RGWSI_MetaBackend_Handler::Op *op,
std::string& entry,
RGWMetadataObject **obj,
optional_yield y,
const DoutPrefixProvider *dpp) final;
int do_remove(RGWSI_MetaBackend_Handler::Op *op,
std::string& entry,
RGWObjVersionTracker& objv_tracker,
optional_yield y,
const DoutPrefixProvider *dpp) final;
int do_put(RGWSI_MetaBackend_Handler::Op *op,
std::string& entr,
RGWMetadataObject *obj,
RGWObjVersionTracker& objv_tracker,
optional_yield y,
const DoutPrefixProvider *dpp,
RGWMDLogSyncType type,
bool from_remote_zone) override;
private:
Driver* driver;
};
} } // namespace rgw::sal
| 7,005 | 32.361905 | 154 |
h
|
null |
ceph-main/src/rgw/rgw_s3select.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#include "rgw_s3select_private.h"
#define dout_subsys ceph_subsys_rgw
namespace rgw::s3select {
RGWOp* create_s3select_op()
{
return new RGWSelectObj_ObjStore_S3();
}
};
using namespace s3selectEngine;
std::string& aws_response_handler::get_sql_result()
{
return sql_result;
}
uint64_t aws_response_handler::get_processed_size()
{
return processed_size;
}
void aws_response_handler::update_processed_size(uint64_t value)
{
processed_size += value;
}
uint64_t aws_response_handler::get_total_bytes_returned()
{
return total_bytes_returned;
}
void aws_response_handler::update_total_bytes_returned(uint64_t value)
{
total_bytes_returned = value;
}
void aws_response_handler::push_header(const char* header_name, const char* header_value)
{
char x;
short s;
x = char(strlen(header_name));
m_buff_header.append(&x, sizeof(x));
m_buff_header.append(header_name);
x = char(7);
m_buff_header.append(&x, sizeof(x));
s = htons(uint16_t(strlen(header_value)));
m_buff_header.append(reinterpret_cast<char*>(&s), sizeof(s));
m_buff_header.append(header_value);
}
#define IDX( x ) static_cast<int>( x )
int aws_response_handler::create_header_records()
{
//headers description(AWS)
//[header-name-byte-length:1][header-name:variable-length][header-value-type:1][header-value:variable-length]
//1
push_header(header_name_str[IDX(header_name_En::EVENT_TYPE)], header_value_str[IDX(header_value_En::RECORDS)]);
//2
push_header(header_name_str[IDX(header_name_En::CONTENT_TYPE)], header_value_str[IDX(header_value_En::OCTET_STREAM)]);
//3
push_header(header_name_str[IDX(header_name_En::MESSAGE_TYPE)], header_value_str[IDX(header_value_En::EVENT)]);
return m_buff_header.size();
}
int aws_response_handler::create_header_continuation()
{
//headers description(AWS)
//1
push_header(header_name_str[IDX(header_name_En::EVENT_TYPE)], header_value_str[IDX(header_value_En::CONT)]);
//2
push_header(header_name_str[IDX(header_name_En::MESSAGE_TYPE)], header_value_str[IDX(header_value_En::EVENT)]);
return m_buff_header.size();
}
int aws_response_handler::create_header_progress()
{
//headers description(AWS)
//1
push_header(header_name_str[IDX(header_name_En::EVENT_TYPE)], header_value_str[IDX(header_value_En::PROGRESS)]);
//2
push_header(header_name_str[IDX(header_name_En::CONTENT_TYPE)], header_value_str[IDX(header_value_En::XML)]);
//3
push_header(header_name_str[IDX(header_name_En::MESSAGE_TYPE)], header_value_str[IDX(header_value_En::EVENT)]);
return m_buff_header.size();
}
int aws_response_handler::create_header_stats()
{
//headers description(AWS)
//1
push_header(header_name_str[IDX(header_name_En::EVENT_TYPE)], header_value_str[IDX(header_value_En::STATS)]);
//2
push_header(header_name_str[IDX(header_name_En::CONTENT_TYPE)], header_value_str[IDX(header_value_En::XML)]);
//3
push_header(header_name_str[IDX(header_name_En::MESSAGE_TYPE)], header_value_str[IDX(header_value_En::EVENT)]);
return m_buff_header.size();
}
int aws_response_handler::create_header_end()
{
//headers description(AWS)
//1
push_header(header_name_str[IDX(header_name_En::EVENT_TYPE)], header_value_str[IDX(header_value_En::END)]);
//2
push_header(header_name_str[IDX(header_name_En::MESSAGE_TYPE)], header_value_str[IDX(header_value_En::EVENT)]);
return m_buff_header.size();
}
int aws_response_handler::create_error_header_records(const char* error_message)
{
//headers description(AWS)
//[header-name-byte-length:1][header-name:variable-length][header-value-type:1][header-value:variable-length]
//1
push_header(header_name_str[IDX(header_name_En::ERROR_CODE)], header_value_str[IDX(header_value_En::ENGINE_ERROR)]);
//2
push_header(header_name_str[IDX(header_name_En::ERROR_MESSAGE)], error_message);
//3
push_header(header_name_str[IDX(header_name_En::MESSAGE_TYPE)], header_value_str[IDX(header_value_En::ERROR_TYPE)]);
return m_buff_header.size();
}
int aws_response_handler::create_message(u_int32_t header_len)
{
//message description(AWS):
//[total-byte-length:4][header-byte-length:4][crc:4][headers:variable-length][payload:variable-length][crc:4]
//s3select result is produced into sql_result, the sql_result is also the response-message, thus the attach headers and CRC
//are created later to the produced SQL result, and actually wrapping the payload.
auto push_encode_int = [&](u_int32_t s, int pos) {
u_int32_t x = htonl(s);
sql_result.replace(pos, sizeof(x), reinterpret_cast<char*>(&x), sizeof(x));
};
u_int32_t total_byte_len = 0;
u_int32_t preload_crc = 0;
u_int32_t message_crc = 0;
total_byte_len = sql_result.size() + 4; //the total is greater in 4 bytes than current size
push_encode_int(total_byte_len, 0);
push_encode_int(header_len, 4);
crc32.reset();
crc32 = std::for_each(sql_result.data(), sql_result.data() + 8, crc32); //crc for starting 8 bytes
preload_crc = crc32();
push_encode_int(preload_crc, 8);
crc32.reset();
crc32 = std::for_each(sql_result.begin(), sql_result.end(), crc32); //crc for payload + checksum
message_crc = crc32();
u_int32_t x = htonl(message_crc);
sql_result.append(reinterpret_cast<char*>(&x), sizeof(x));
return sql_result.size();
}
void aws_response_handler::init_response()
{
//12 positions for header-crc
sql_result.resize(header_crc_size, '\0');
}
void aws_response_handler::init_success_response()
{
m_buff_header.clear();
header_size = create_header_records();
sql_result.append(m_buff_header.c_str(), header_size);
#ifdef PAYLOAD_TAG
sql_result.append(PAYLOAD_LINE);
#endif
}
void aws_response_handler::send_continuation_response()
{
sql_result.resize(header_crc_size, '\0');
m_buff_header.clear();
header_size = create_header_continuation();
sql_result.append(m_buff_header.c_str(), header_size);
int buff_len = create_message(header_size);
s->formatter->write_bin_data(sql_result.data(), buff_len);
rgw_flush_formatter_and_reset(s, s->formatter);
}
void aws_response_handler::init_progress_response()
{
sql_result.resize(header_crc_size, '\0');
m_buff_header.clear();
header_size = create_header_progress();
sql_result.append(m_buff_header.c_str(), header_size);
}
void aws_response_handler::init_stats_response()
{
sql_result.resize(header_crc_size, '\0');
m_buff_header.clear();
header_size = create_header_stats();
sql_result.append(m_buff_header.c_str(), header_size);
}
void aws_response_handler::init_end_response()
{
sql_result.resize(header_crc_size, '\0');
m_buff_header.clear();
header_size = create_header_end();
sql_result.append(m_buff_header.c_str(), header_size);
int buff_len = create_message(header_size);
s->formatter->write_bin_data(sql_result.data(), buff_len);
rgw_flush_formatter_and_reset(s, s->formatter);
}
void aws_response_handler::init_error_response(const char* error_message)
{
//currently not in use. the headers in the case of error, are not extracted by AWS-cli.
m_buff_header.clear();
header_size = create_error_header_records(error_message);
sql_result.append(m_buff_header.c_str(), header_size);
}
void aws_response_handler::send_success_response()
{
#ifdef PAYLOAD_TAG
sql_result.append(END_PAYLOAD_LINE);
#endif
int buff_len = create_message(header_size);
s->formatter->write_bin_data(sql_result.data(), buff_len);
rgw_flush_formatter_and_reset(s, s->formatter);
}
void aws_response_handler::send_error_response(const char* error_code,
const char* error_message,
const char* resource_id)
{
set_req_state_err(s, 0);
dump_errno(s, 400);
end_header(s, m_rgwop, "application/xml", CHUNKED_TRANSFER_ENCODING);
dump_start(s);
s->formatter->open_object_section("Error");
s->formatter->dump_string("Code", error_code);
s->formatter->dump_string("Message", error_message);
s->formatter->dump_string("Resource", "#Resource#");
s->formatter->dump_string("RequestId", resource_id);
s->formatter->close_section();
rgw_flush_formatter_and_reset(s, s->formatter);
}
void aws_response_handler::send_progress_response()
{
std::string progress_payload = fmt::format("<?xml version=\"1.0\" encoding=\"UTF-8\"?><Progress><BytesScanned>{}</BytesScanned><BytesProcessed>{}</BytesProcessed><BytesReturned>{}</BytesReturned></Progress>"
, get_processed_size(), get_processed_size(), get_total_bytes_returned());
sql_result.append(progress_payload);
int buff_len = create_message(header_size);
s->formatter->write_bin_data(sql_result.data(), buff_len);
rgw_flush_formatter_and_reset(s, s->formatter);
}
void aws_response_handler::send_stats_response()
{
std::string stats_payload = fmt::format("<?xml version=\"1.0\" encoding=\"UTF-8\"?><Stats><BytesScanned>{}</BytesScanned><BytesProcessed>{}</BytesProcessed><BytesReturned>{}</BytesReturned></Stats>"
, get_processed_size(), get_processed_size(), get_total_bytes_returned());
sql_result.append(stats_payload);
int buff_len = create_message(header_size);
s->formatter->write_bin_data(sql_result.data(), buff_len);
rgw_flush_formatter_and_reset(s, s->formatter);
}
RGWSelectObj_ObjStore_S3::RGWSelectObj_ObjStore_S3():
m_buff_header(std::make_unique<char[]>(1000)),
m_scan_range_ind(false),
m_start_scan_sz(0),
m_end_scan_sz(0),
m_object_size_for_processing(0),
m_parquet_type(false),
m_json_type(false),
chunk_number(0),
m_requested_range(0),
m_scan_offset(1024),
m_skip_next_chunk(false),
m_is_trino_request(false)
{
set_get_data(true);
fp_get_obj_size = [&]() {
return get_obj_size();
};
fp_range_req = [&](int64_t start, int64_t len, void* buff, optional_yield* y) {
ldout(s->cct, 10) << "S3select: range-request start: " << start << " length: " << len << dendl;
auto status = range_request(start, len, buff, *y);
return status;
};
#ifdef _ARROW_EXIST
m_rgw_api.set_get_size_api(fp_get_obj_size);
m_rgw_api.set_range_req_api(fp_range_req);
#endif
fp_result_header_format = [this](std::string& result) {
m_aws_response_handler.init_response();
m_aws_response_handler.init_success_response();
return 0;
};
fp_s3select_result_format = [this](std::string& result) {
fp_chunked_transfer_encoding();
m_aws_response_handler.send_success_response();
return 0;
};
fp_debug_mesg = [&](const char* mesg){
ldpp_dout(this, 10) << mesg << dendl;
};
fp_chunked_transfer_encoding = [&](void){
if (chunk_number == 0) {
if (op_ret < 0) {
set_req_state_err(s, op_ret);
}
dump_errno(s);
// Explicitly use chunked transfer encoding so that we can stream the result
// to the user without having to wait for the full length of it.
end_header(s, this, "application/xml", CHUNKED_TRANSFER_ENCODING);
}
chunk_number++;
};
}
RGWSelectObj_ObjStore_S3::~RGWSelectObj_ObjStore_S3()
{}
int RGWSelectObj_ObjStore_S3::get_params(optional_yield y)
{
if(m_s3select_query.empty() == false) {
return 0;
}
#ifndef _ARROW_EXIST
m_parquet_type = false;
ldpp_dout(this, 10) << "arrow library is not installed" << dendl;
#endif
//retrieve s3-select query from payload
bufferlist data;
int ret;
int max_size = 4096;
std::tie(ret, data) = read_all_input(s, max_size, false);
if (ret != 0) {
ldpp_dout(this, 10) << "s3-select query: failed to retrieve query; ret = " << ret << dendl;
return ret;
}
m_s3select_query = data.to_str();
if (m_s3select_query.length() > 0) {
ldpp_dout(this, 10) << "s3-select query: " << m_s3select_query << dendl;
} else {
ldpp_dout(this, 10) << "s3-select query: failed to retrieve query;" << dendl;
return -1;
}
const auto& m = s->info.env->get_map();
auto user_agent = m.find("HTTP_USER_AGENT"); {
if (user_agent != m.end()){
if (user_agent->second.find("Trino") != std::string::npos){
m_is_trino_request = true;
ldpp_dout(this, 10) << "s3-select query: request sent by Trino." << dendl;
}
}
}
int status = handle_aws_cli_parameters(m_sql_query);
if (status<0) {
return status;
}
return RGWGetObj_ObjStore_S3::get_params(y);
}
int RGWSelectObj_ObjStore_S3::run_s3select_on_csv(const char* query, const char* input, size_t input_length)
{
int status = 0;
uint32_t length_before_processing, length_post_processing;
csv_object::csv_defintions csv;
const char* s3select_syntax_error = "s3select-Syntax-Error";
const char* s3select_resource_id = "resourcse-id";
const char* s3select_processTime_error = "s3select-ProcessingTime-Error";
s3select_syntax.parse_query(query);
if (m_row_delimiter.size()) {
csv.row_delimiter = *m_row_delimiter.c_str();
}
if (m_column_delimiter.size()) {
csv.column_delimiter = *m_column_delimiter.c_str();
}
if (m_quot.size()) {
csv.quot_char = *m_quot.c_str();
}
if (m_escape_char.size()) {
csv.escape_char = *m_escape_char.c_str();
}
if (output_row_delimiter.size()) {
csv.output_row_delimiter = *output_row_delimiter.c_str();
}
if (output_column_delimiter.size()) {
csv.output_column_delimiter = *output_column_delimiter.c_str();
}
if (output_quot.size()) {
csv.output_quot_char = *output_quot.c_str();
}
if (output_escape_char.size()) {
csv.output_escape_char = *output_escape_char.c_str();
}
if(output_quote_fields.compare("ALWAYS") == 0) {
csv.quote_fields_always = true;
} else if(output_quote_fields.compare("ASNEEDED") == 0) {
csv.quote_fields_asneeded = true;
}
if(m_header_info.compare("IGNORE")==0) {
csv.ignore_header_info=true;
} else if(m_header_info.compare("USE")==0) {
csv.use_header_info=true;
}
//m_s3_csv_object.set_external_debug_system(fp_debug_mesg);
m_s3_csv_object.set_result_formatters(fp_s3select_result_format,fp_result_header_format);
m_s3_csv_object.set_csv_query(&s3select_syntax, csv);
if (s3select_syntax.get_error_description().empty() == false) {
//error-flow (syntax-error)
m_aws_response_handler.send_error_response(s3select_syntax_error,
s3select_syntax.get_error_description().c_str(),
s3select_resource_id);
ldpp_dout(this, 10) << "s3-select query: failed to prase the following query {" << query << "}" << dendl;
ldpp_dout(this, 10) << "s3-select query: syntax-error {" << s3select_syntax.get_error_description() << "}" << dendl;
return -1;
} else {
if (input == nullptr) {
input = "";
}
fp_result_header_format(m_aws_response_handler.get_sql_result());
length_before_processing = m_s3_csv_object.get_return_result_size();
//query is correct(syntax), processing is starting.
status = m_s3_csv_object.run_s3select_on_stream(m_aws_response_handler.get_sql_result(), input, input_length, m_object_size_for_processing);
length_post_processing = m_s3_csv_object.get_return_result_size();
m_aws_response_handler.update_total_bytes_returned( m_s3_csv_object.get_return_result_size() );
if (status < 0) {
//error flow(processing-time)
m_aws_response_handler.send_error_response(s3select_processTime_error,
m_s3_csv_object.get_error_description().c_str(),
s3select_resource_id);
ldpp_dout(this, 10) << "s3-select query: failed to process query; {" << m_s3_csv_object.get_error_description() << "}" << dendl;
return -1;
}
}
if ((length_post_processing-length_before_processing) != 0) {
ldpp_dout(this, 10) << "s3-select: sql-result-size = " << m_aws_response_handler.get_sql_result().size() << dendl;
} else {
m_aws_response_handler.send_continuation_response();
}
if (enable_progress == true) {
fp_chunked_transfer_encoding();
m_aws_response_handler.init_progress_response();
m_aws_response_handler.send_progress_response();
}
return status;
}
int RGWSelectObj_ObjStore_S3::run_s3select_on_parquet(const char* query)
{
int status = 0;
#ifdef _ARROW_EXIST
if (!m_s3_parquet_object.is_set()) {
//parsing the SQL statement
s3select_syntax.parse_query(m_sql_query.c_str());
//m_s3_parquet_object.set_external_debug_system(fp_debug_mesg);
try {
//at this stage the Parquet-processing requires for the meta-data that reside on Parquet object
m_s3_parquet_object.set_parquet_object(std::string("s3object"), &s3select_syntax, &m_rgw_api);
} catch(base_s3select_exception& e) {
ldpp_dout(this, 10) << "S3select: failed upon parquet-reader construction: " << e.what() << dendl;
fp_result_header_format(m_aws_response_handler.get_sql_result());
m_aws_response_handler.get_sql_result().append(e.what());
fp_s3select_result_format(m_aws_response_handler.get_sql_result());
return -1;
}
}
if (s3select_syntax.get_error_description().empty() == false) {
//the SQL statement failed the syntax parser
fp_result_header_format(m_aws_response_handler.get_sql_result());
m_aws_response_handler.get_sql_result().append(s3select_syntax.get_error_description().data());
fp_s3select_result_format(m_aws_response_handler.get_sql_result());
ldpp_dout(this, 10) << "s3-select query: failed to prase query; {" << s3select_syntax.get_error_description() << "}" << dendl;
status = -1;
} else {
fp_result_header_format(m_aws_response_handler.get_sql_result());
//at this stage the Parquet-processing "takes control", it keep calling to s3-range-request according to the SQL statement.
status = m_s3_parquet_object.run_s3select_on_object(m_aws_response_handler.get_sql_result(), fp_s3select_result_format, fp_result_header_format);
if (status < 0) {
m_aws_response_handler.get_sql_result().append(m_s3_parquet_object.get_error_description());
fp_s3select_result_format(m_aws_response_handler.get_sql_result());
ldout(s->cct, 10) << "S3select: failure while execution" << m_s3_parquet_object.get_error_description() << dendl;
}
}
#endif
return status;
}
int RGWSelectObj_ObjStore_S3::run_s3select_on_json(const char* query, const char* input, size_t input_length)
{
int status = 0;
const char* s3select_processTime_error = "s3select-ProcessingTime-Error";
const char* s3select_syntax_error = "s3select-Syntax-Error";
const char* s3select_resource_id = "resourcse-id";
const char* s3select_json_error = "json-Format-Error";
m_aws_response_handler.init_response();
//the JSON data-type should be(currently) only DOCUMENT
if (m_json_datatype.compare("DOCUMENT") != 0) {
const char* s3select_json_error_msg = "s3-select query: wrong json dataType should use DOCUMENT; ";
m_aws_response_handler.send_error_response(s3select_json_error,
s3select_json_error_msg,
s3select_resource_id);
ldpp_dout(this, 10) << s3select_json_error_msg << dendl;
return -EINVAL;
}
//parsing the SQL statement
s3select_syntax.parse_query(m_sql_query.c_str());
if (s3select_syntax.get_error_description().empty() == false) {
//SQL statement is wrong(syntax).
m_aws_response_handler.send_error_response(s3select_syntax_error,
s3select_syntax.get_error_description().c_str(),
s3select_resource_id);
ldpp_dout(this, 10) << "s3-select query: failed to prase query; {" << s3select_syntax.get_error_description() << "}" << dendl;
return -EINVAL;
}
//initializing json processor
m_s3_json_object.set_json_query(&s3select_syntax);
if (input == nullptr) {
input = "";
}
m_aws_response_handler.init_success_response();
uint32_t length_before_processing = m_aws_response_handler.get_sql_result().size();
//query is correct(syntax), processing is starting.
try {
status = m_s3_json_object.run_s3select_on_stream(m_aws_response_handler.get_sql_result(), input, input_length, m_object_size_for_processing);
} catch(base_s3select_exception& e) {
ldpp_dout(this, 10) << "S3select: failed to process JSON object: " << e.what() << dendl;
m_aws_response_handler.get_sql_result().append(e.what());
m_aws_response_handler.send_error_response(s3select_processTime_error,
e.what(),
s3select_resource_id);
return -EINVAL;
}
uint32_t length_post_processing = m_aws_response_handler.get_sql_result().size();
m_aws_response_handler.update_total_bytes_returned(length_post_processing - length_before_processing);
if (status < 0) {
//error flow(processing-time)
m_aws_response_handler.send_error_response(s3select_processTime_error,
m_s3_json_object.get_error_description().c_str(),
s3select_resource_id);
ldpp_dout(this, 10) << "s3-select query: failed to process query; {" << m_s3_json_object.get_error_description() << "}" << dendl;
return -EINVAL;
}
fp_chunked_transfer_encoding();
if (length_post_processing-length_before_processing != 0) {
m_aws_response_handler.send_success_response();
} else {
m_aws_response_handler.send_continuation_response();
}
if (enable_progress == true) {
m_aws_response_handler.init_progress_response();
m_aws_response_handler.send_progress_response();
}
return status;
}
int RGWSelectObj_ObjStore_S3::handle_aws_cli_parameters(std::string& sql_query)
{
std::string input_tag{"InputSerialization"};
std::string output_tag{"OutputSerialization"};
if (chunk_number !=0) {
return 0;
}
#define GT ">"
#define LT "<"
#define APOS "'"
if (m_s3select_query.find(GT) != std::string::npos) {
boost::replace_all(m_s3select_query, GT, ">");
}
if (m_s3select_query.find(LT) != std::string::npos) {
boost::replace_all(m_s3select_query, LT, "<");
}
if (m_s3select_query.find(APOS) != std::string::npos) {
boost::replace_all(m_s3select_query, APOS, "'");
}
//AWS cli s3select parameters
if (m_s3select_query.find(input_tag+"><CSV") != std::string::npos) {
ldpp_dout(this, 10) << "s3select: engine is set to process CSV objects" << dendl;
}
else if (m_s3select_query.find(input_tag+"><JSON") != std::string::npos) {
m_json_type=true;
ldpp_dout(this, 10) << "s3select: engine is set to process JSON objects" << dendl;
} else if (m_s3select_query.find(input_tag+"><Parquet") != std::string::npos) {
m_parquet_type=true;
ldpp_dout(this, 10) << "s3select: engine is set to process Parquet objects" << dendl;
}
extract_by_tag(m_s3select_query, "Expression", sql_query);
extract_by_tag(m_s3select_query, "Enabled", m_enable_progress);
size_t _qi = m_s3select_query.find("<" + input_tag + ">", 0);
size_t _qe = m_s3select_query.find("</" + input_tag + ">", _qi);
m_s3select_input = m_s3select_query.substr(_qi + input_tag.size() + 2, _qe - (_qi + input_tag.size() + 2));
extract_by_tag(m_s3select_input, "FieldDelimiter", m_column_delimiter);
extract_by_tag(m_s3select_input, "QuoteCharacter", m_quot);
extract_by_tag(m_s3select_input, "RecordDelimiter", m_row_delimiter);
extract_by_tag(m_s3select_input, "FileHeaderInfo", m_header_info);
extract_by_tag(m_s3select_input, "Type", m_json_datatype);
if (m_row_delimiter.size()==0) {
m_row_delimiter='\n';
} else if (m_row_delimiter.compare(" ") == 0) {
//presto change
m_row_delimiter='\n';
}
extract_by_tag(m_s3select_input, "QuoteEscapeCharacter", m_escape_char);
extract_by_tag(m_s3select_input, "CompressionType", m_compression_type);
size_t _qo = m_s3select_query.find("<" + output_tag + ">", 0);
size_t _qs = m_s3select_query.find("</" + output_tag + ">", _qi);
m_s3select_output = m_s3select_query.substr(_qo + output_tag.size() + 2, _qs - (_qo + output_tag.size() + 2));
extract_by_tag(m_s3select_output, "FieldDelimiter", output_column_delimiter);
extract_by_tag(m_s3select_output, "QuoteCharacter", output_quot);
extract_by_tag(m_s3select_output, "QuoteEscapeCharacter", output_escape_char);
extract_by_tag(m_s3select_output, "QuoteFields", output_quote_fields);
extract_by_tag(m_s3select_output, "RecordDelimiter", output_row_delimiter);
if (output_row_delimiter.size()==0) {
output_row_delimiter='\n';
} else if (output_row_delimiter.compare(" ") == 0) {
//presto change
output_row_delimiter='\n';
}
if (m_compression_type.length()>0 && m_compression_type.compare("NONE") != 0) {
ldpp_dout(this, 10) << "RGW supports currently only NONE option for compression type" << dendl;
return -1;
}
extract_by_tag(m_s3select_query, "Start", m_start_scan);
extract_by_tag(m_s3select_query, "End", m_end_scan);
if (m_start_scan.size() || m_end_scan.size()) {
m_scan_range_ind = true;
if (m_start_scan.size()) {
m_start_scan_sz = std::stol(m_start_scan);
}
if (m_end_scan.size()) {
m_end_scan_sz = std::stol(m_end_scan);
} else {
m_end_scan_sz = std::numeric_limits<std::int64_t>::max();
}
}
if (m_enable_progress.compare("true")==0) {
enable_progress = true;
} else {
enable_progress = false;
}
return 0;
}
int RGWSelectObj_ObjStore_S3::extract_by_tag(std::string input, std::string tag_name, std::string& result)
{
result = "";
size_t _qs = input.find("<" + tag_name + ">", 0);
size_t qs_input = _qs + tag_name.size() + 2;
if (_qs == std::string::npos) {
return -1;
}
size_t _qe = input.find("</" + tag_name + ">", qs_input);
if (_qe == std::string::npos) {
return -1;
}
result = input.substr(qs_input, _qe - qs_input);
return 0;
}
size_t RGWSelectObj_ObjStore_S3::get_obj_size()
{
return s->obj_size;
}
int RGWSelectObj_ObjStore_S3::range_request(int64_t ofs, int64_t len, void* buff, optional_yield y)
{
//purpose: implementation for arrow::ReadAt, this may take several async calls.
//send_response_date(call_back) accumulate buffer, upon completion control is back to ReadAt.
range_req_str = "bytes=" + std::to_string(ofs) + "-" + std::to_string(ofs+len-1);
range_str = range_req_str.c_str();
range_parsed = false;
RGWGetObj::parse_range();
requested_buffer.clear();
m_request_range = len;
ldout(s->cct, 10) << "S3select: calling execute(async):" << " request-offset :" << ofs << " request-length :" << len << " buffer size : " << requested_buffer.size() << dendl;
RGWGetObj::execute(y);
if (buff) {
memcpy(buff, requested_buffer.data(), len);
}
ldout(s->cct, 10) << "S3select: done waiting, buffer is complete buffer-size:" << requested_buffer.size() << dendl;
return len;
}
void RGWSelectObj_ObjStore_S3::execute(optional_yield y)
{
int status = 0;
char parquet_magic[4];
static constexpr uint8_t parquet_magic1[4] = {'P', 'A', 'R', '1'};
static constexpr uint8_t parquet_magicE[4] = {'P', 'A', 'R', 'E'};
get_params(y);
#ifdef _ARROW_EXIST
m_rgw_api.m_y = &y;
#endif
if (m_parquet_type) {
//parquet processing
range_request(0, 4, parquet_magic, y);
if (memcmp(parquet_magic, parquet_magic1, 4) && memcmp(parquet_magic, parquet_magicE, 4)) {
ldout(s->cct, 10) << s->object->get_name() << " does not contain parquet magic" << dendl;
op_ret = -ERR_INVALID_REQUEST;
return;
}
s3select_syntax.parse_query(m_sql_query.c_str());
status = run_s3select_on_parquet(m_sql_query.c_str());
if (status) {
ldout(s->cct, 10) << "S3select: failed to process query <" << m_sql_query << "> on object " << s->object->get_name() << dendl;
op_ret = -ERR_INVALID_REQUEST;
} else {
ldout(s->cct, 10) << "S3select: complete query with success " << dendl;
}
} else {
//CSV or JSON processing
if (m_scan_range_ind) {
m_requested_range = (m_end_scan_sz - m_start_scan_sz);
if(m_is_trino_request){
// fetch more than requested(m_scan_offset), that additional bytes are scanned for end of row,
// thus the additional length will be processed, and no broken row for Trino.
// assumption: row is smaller than m_scan_offset. (a different approach is to request for additional range)
range_request(m_start_scan_sz, m_requested_range + m_scan_offset, nullptr, y);
} else {
range_request(m_start_scan_sz, m_requested_range, nullptr, y);
}
} else {
RGWGetObj::execute(y);
}
}//if (m_parquet_type)
}
int RGWSelectObj_ObjStore_S3::parquet_processing(bufferlist& bl, off_t ofs, off_t len)
{
fp_chunked_transfer_encoding();
size_t append_in_callback = 0;
int part_no = 1;
//concat the requested buffer
for (auto& it : bl.buffers()) {
if (it.length() == 0) {
ldout(s->cct, 10) << "S3select: get zero-buffer while appending request-buffer " << dendl;
}
append_in_callback += it.length();
ldout(s->cct, 10) << "S3select: part " << part_no++ << " it.length() = " << it.length() << dendl;
requested_buffer.append(&(it)[0]+ofs, len);
}
ldout(s->cct, 10) << "S3select:append_in_callback = " << append_in_callback << dendl;
if (requested_buffer.size() < m_request_range) {
ldout(s->cct, 10) << "S3select: need another round buffe-size: " << requested_buffer.size() << " request range length:" << m_request_range << dendl;
return 0;
} else {//buffer is complete
ldout(s->cct, 10) << "S3select: buffer is complete " << requested_buffer.size() << " request range length:" << m_request_range << dendl;
m_request_range = 0;
}
return 0;
}
void RGWSelectObj_ObjStore_S3::shape_chunk_per_trino_requests(const char* it_cp, off_t& ofs, off_t& len)
{
//in case it is a scan range request and sent by Trino client.
//this routine chops the start/end of chunks.
//the purpose is to return "perfect" results, with no broken or missing lines.
off_t new_offset = 0;
if(m_scan_range_ind){//only upon range-scan
int64_t sc=0;
int64_t start =0;
const char* row_delimiter = m_row_delimiter.c_str();
ldpp_dout(this, 10) << "s3select query: per Trino request the first and last chunk should modified." << dendl;
//chop the head of the first chunk and only upon the slice does not include the head of the object.
if(m_start_scan_sz && (m_aws_response_handler.get_processed_size()==0)){
char* p = const_cast<char*>(it_cp+ofs);
while(strncmp(row_delimiter,p,1) && (p - (it_cp+ofs)) < len)p++;
if(!strncmp(row_delimiter,p,1)){
new_offset += (p - (it_cp+ofs))+1;
}
}
//RR : end of the range-request. the original request sent by Trino client
//RD : row-delimiter
//[ ... ] : chunk boundaries
//chop the end of the last chunk for this request
//if it's the last chunk, search for first row-delimiter for the following different use-cases
if((m_aws_response_handler.get_processed_size()+len) >= m_requested_range){
//had pass the requested range, start to search for first delimiter
if(m_aws_response_handler.get_processed_size()>m_requested_range){
//the previous chunk contain the complete request(all data) and an extra bytes.
//thus, search for the first row-delimiter
//[:previous (RR) ... ][:current (RD) ]
start = 0;
} else if(m_aws_response_handler.get_processed_size()){
//the *current* chunk contain the complete request in the middle of the chunk.
//thus, search for the first row-delimiter after the complete request position
//[:current (RR) .... (RD) ]
start = m_requested_range - m_aws_response_handler.get_processed_size();
} else {
//the current chunk is the first chunk and it contains complete request
//[:current:first-chunk (RR) .... (RD) ]
start = m_requested_range;
}
for(sc=start;sc<len;sc++)//assumption : row-delimiter must exist or its end ebject
{
char* p = const_cast<char*>(it_cp) + ofs + sc;
if(!strncmp(row_delimiter,p,1)){
ldout(s->cct, 10) << "S3select: found row-delimiter on " << sc << " get_processed_size = " << m_aws_response_handler.get_processed_size() << dendl;
len = sc + 1;//+1 is for delimiter. TODO what about m_object_size_for_processing (to update according to len)
//the end of row exist in current chunk.
//thus, the next chunk should be skipped
m_skip_next_chunk = true;
break;
}
}
}
ofs += new_offset;
}
ldout(s->cct, 10) << "S3select: shape_chunk_per_trino_requests:update progress len = " << len << dendl;
len -= new_offset;
}
int RGWSelectObj_ObjStore_S3::csv_processing(bufferlist& bl, off_t ofs, off_t len)
{
int status = 0;
if(m_skip_next_chunk == true){
return status;
}
if (s->obj_size == 0 || m_object_size_for_processing == 0) {
status = run_s3select_on_csv(m_sql_query.c_str(), nullptr, 0);
if (status<0){
return -EINVAL;
}
} else {
auto bl_len = bl.get_num_buffers();
int buff_no=0;
for(auto& it : bl.buffers()) {
ldpp_dout(this, 10) << "s3select :processing segment " << buff_no << " out of " << bl_len << " off " << ofs
<< " len " << len << " obj-size " << m_object_size_for_processing << dendl;
if (it.length() == 0 || len == 0) {
ldpp_dout(this, 10) << "s3select :it->_len is zero. segment " << buff_no << " out of " << bl_len
<< " obj-size " << m_object_size_for_processing << dendl;
continue;
}
if((ofs + len) > it.length()){
ldpp_dout(this, 10) << "offset and length may cause invalid read: ofs = " << ofs << " len = " << len << " it.length() = " << it.length() << dendl;
ofs = 0;
len = it.length();
}
if(m_is_trino_request){
shape_chunk_per_trino_requests(&(it)[0], ofs, len);
}
ldpp_dout(this, 10) << "s3select: chunk: ofs = " << ofs << " len = " << len << " it.length() = " << it.length() << " m_object_size_for_processing = " << m_object_size_for_processing << dendl;
m_aws_response_handler.update_processed_size(it.length());//NOTE : to run analysis to validate len is aligned with m_processed_bytes
status = run_s3select_on_csv(m_sql_query.c_str(), &(it)[0] + ofs, len);
if (status<0) {
return -EINVAL;
}
if (m_s3_csv_object.is_sql_limit_reached()) {
break;
}
buff_no++;
}//for
}//else
ldpp_dout(this, 10) << "s3select : m_aws_response_handler.get_processed_size() " << m_aws_response_handler.get_processed_size()
<< " m_object_size_for_processing " << uint64_t(m_object_size_for_processing) << dendl;
if (m_aws_response_handler.get_processed_size() >= uint64_t(m_object_size_for_processing) || m_s3_csv_object.is_sql_limit_reached()) {
if (status >=0) {
m_aws_response_handler.init_stats_response();
m_aws_response_handler.send_stats_response();
m_aws_response_handler.init_end_response();
ldpp_dout(this, 10) << "s3select : reached the end of query request : aws_response_handler.get_processed_size() " << m_aws_response_handler.get_processed_size()
<< "m_object_size_for_processing : " << m_object_size_for_processing << dendl;
}
if (m_s3_csv_object.is_sql_limit_reached()) {
//stop fetching chunks
ldpp_dout(this, 10) << "s3select : reached the limit :" << m_aws_response_handler.get_processed_size() << dendl;
status = -ENOENT;
}
}
return status;
}
int RGWSelectObj_ObjStore_S3::json_processing(bufferlist& bl, off_t ofs, off_t len)
{
int status = 0;
if (s->obj_size == 0 || m_object_size_for_processing == 0) {
//in case of empty object the s3select-function returns a correct "empty" result(for aggregation and non-aggregation queries).
status = run_s3select_on_json(m_sql_query.c_str(), nullptr, 0);
if (status<0)
return -EINVAL;
} else {
//loop on buffer-list(chunks)
auto bl_len = bl.get_num_buffers();
int i=0;
for(auto& it : bl.buffers()) {
ldpp_dout(this, 10) << "processing segment " << i << " out of " << bl_len << " off " << ofs
<< " len " << len << " obj-size " << m_object_size_for_processing << dendl;
//skipping the empty chunks
if (len == 0) {
ldpp_dout(this, 10) << "s3select:it->_len is zero. segment " << i << " out of " << bl_len
<< " obj-size " << m_object_size_for_processing << dendl;
continue;
}
if((ofs + len) > it.length()){
ldpp_dout(this, 10) << "s3select: offset and length may cause invalid read: ofs = " << ofs << " len = " << len << " it.length() = " << it.length() << dendl;
ofs = 0;
len = it.length();
}
m_aws_response_handler.update_processed_size(len);
status = run_s3select_on_json(m_sql_query.c_str(), &(it)[0] + ofs, len);
if (status<0) {
status = -EINVAL;
break;
}
if (m_s3_json_object.is_sql_limit_reached()) {
break;
}
i++;
}//for
}//else
if (status>=0 && (m_aws_response_handler.get_processed_size() == uint64_t(m_object_size_for_processing) || m_s3_json_object.is_sql_limit_reached())) {
//flush the internal JSON buffer(upon last chunk)
status = run_s3select_on_json(m_sql_query.c_str(), nullptr, 0);
if (status<0) {
return -EINVAL;
}
if (status >=0) {
m_aws_response_handler.init_stats_response();
m_aws_response_handler.send_stats_response();
m_aws_response_handler.init_end_response();
}
if (m_s3_json_object.is_sql_limit_reached()){
//stop fetching chunks
status = -ENOENT;
ldpp_dout(this, 10) << "s3select : reached the limit :" << m_aws_response_handler.get_processed_size() << dendl;
}
}
return status;
}
int RGWSelectObj_ObjStore_S3::send_response_data(bufferlist& bl, off_t ofs, off_t len)
{
if (m_scan_range_ind == false){
m_object_size_for_processing = s->obj_size;
}
if (m_scan_range_ind == true){
if (m_end_scan_sz == -1){
m_end_scan_sz = s->obj_size;
}
if (static_cast<uint64_t>((m_end_scan_sz - m_start_scan_sz))>s->obj_size){ //in the case user provides range bigger than object-size
m_object_size_for_processing = s->obj_size;
} else {
m_object_size_for_processing = m_end_scan_sz - m_start_scan_sz;
}
}
if (!m_aws_response_handler.is_set()) {
m_aws_response_handler.set(s, this);
}
if (len == 0 && s->obj_size != 0) {
return 0;
}
if (m_parquet_type) {
return parquet_processing(bl,ofs,len);
}
if (m_json_type) {
return json_processing(bl,ofs,len);
}
return csv_processing(bl,ofs,len);
}
| 38,228 | 37.190809 | 209 |
cc
|
null |
ceph-main/src/rgw/rgw_s3select.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
//
#pragma once
namespace rgw::s3select {
RGWOp* create_s3select_op();
}
| 181 | 15.545455 | 70 |
h
|
null |
ceph-main/src/rgw/rgw_s3select_private.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
//
#pragma once
#include <errno.h>
#include <array>
#include <string.h>
#include <string_view>
#include "common/ceph_crypto.h"
#include "common/split.h"
#include "common/Formatter.h"
#include "common/utf8.h"
#include "common/ceph_json.h"
#include "common/safe_io.h"
#include "common/errno.h"
#include "auth/Crypto.h"
#include <boost/algorithm/string.hpp>
#include <boost/algorithm/string/replace.hpp>
#include <boost/tokenizer.hpp>
#define BOOST_BIND_GLOBAL_PLACEHOLDERS
#ifdef HAVE_WARN_IMPLICIT_CONST_INT_FLOAT_CONVERSION
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wimplicit-const-int-float-conversion"
#endif
#ifdef HAVE_WARN_IMPLICIT_CONST_INT_FLOAT_CONVERSION
#pragma clang diagnostic pop
#endif
#undef BOOST_BIND_GLOBAL_PLACEHOLDERS
#include <liboath/oath.h>
#pragma GCC diagnostic push
#pragma clang diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated"
#pragma clang diagnostic ignored "-Wdeprecated"
#include <s3select/include/s3select.h>
#pragma GCC diagnostic pop
#pragma clang diagnostic pop
#include "rgw_rest_s3.h"
#include "rgw_s3select.h"
class aws_response_handler
{
private:
std::string sql_result;
req_state* s;
uint32_t header_size;
// the parameters are according to CRC-32 algorithm and its aligned with AWS-cli checksum
boost::crc_optimal<32, 0x04C11DB7, 0xFFFFFFFF, 0xFFFFFFFF, true, true> crc32;
RGWOp* m_rgwop;
std::string m_buff_header;
uint64_t total_bytes_returned;
uint64_t processed_size;
enum class header_name_En {
EVENT_TYPE,
CONTENT_TYPE,
MESSAGE_TYPE,
ERROR_CODE,
ERROR_MESSAGE
};
enum class header_value_En {
RECORDS,
OCTET_STREAM,
EVENT,
CONT,
PROGRESS,
END,
XML,
STATS,
ENGINE_ERROR,
ERROR_TYPE
};
const char* PAYLOAD_LINE= "\n<Payload>\n<Records>\n<Payload>\n";
const char* END_PAYLOAD_LINE= "\n</Payload></Records></Payload>";
const char* header_name_str[5] = {":event-type", ":content-type", ":message-type", ":error-code", ":error-message"};
const char* header_value_str[10] = {"Records", "application/octet-stream", "event", "Cont", "Progress", "End", "text/xml", "Stats", "s3select-engine-error", "error"};
static constexpr size_t header_crc_size = 12;
void push_header(const char* header_name, const char* header_value);
int create_message(u_int32_t header_len);
public:
aws_response_handler(req_state* ps, RGWOp* rgwop) : s(ps), m_rgwop(rgwop), total_bytes_returned{0}, processed_size{0}
{}
aws_response_handler() : s(nullptr), m_rgwop(nullptr), total_bytes_returned{0}, processed_size{0}
{}
bool is_set()
{
if(s==nullptr || m_rgwop == nullptr){
return false;
}
return true;
}
void set(req_state* ps, RGWOp* rgwop)
{
s = ps;
m_rgwop = rgwop;
}
std::string& get_sql_result();
uint64_t get_processed_size();
void update_processed_size(uint64_t value);
uint64_t get_total_bytes_returned();
void update_total_bytes_returned(uint64_t value);
int create_header_records();
int create_header_continuation();
int create_header_progress();
int create_header_stats();
int create_header_end();
int create_error_header_records(const char* error_message);
void init_response();
void init_success_response();
void send_continuation_response();
void init_progress_response();
void init_end_response();
void init_stats_response();
void init_error_response(const char* error_message);
void send_success_response();
void send_progress_response();
void send_stats_response();
void send_error_response(const char* error_code,
const char* error_message,
const char* resource_id);
}; //end class aws_response_handler
class RGWSelectObj_ObjStore_S3 : public RGWGetObj_ObjStore_S3
{
private:
s3selectEngine::s3select s3select_syntax;
std::string m_s3select_query;
std::string m_s3select_input;
std::string m_s3select_output;
s3selectEngine::csv_object m_s3_csv_object;
#ifdef _ARROW_EXIST
s3selectEngine::parquet_object m_s3_parquet_object;
#endif
s3selectEngine::json_object m_s3_json_object;
std::string m_column_delimiter;
std::string m_quot;
std::string m_row_delimiter;
std::string m_compression_type;
std::string m_escape_char;
std::unique_ptr<char[]> m_buff_header;
std::string m_header_info;
std::string m_sql_query;
std::string m_enable_progress;
std::string output_column_delimiter;
std::string output_quot;
std::string output_escape_char;
std::string output_quote_fields;
std::string output_row_delimiter;
std::string m_start_scan;
std::string m_end_scan;
bool m_scan_range_ind;
int64_t m_start_scan_sz;
int64_t m_end_scan_sz;
int64_t m_object_size_for_processing;
aws_response_handler m_aws_response_handler;
bool enable_progress;
//parquet request
bool m_parquet_type;
//json request
std::string m_json_datatype;
bool m_json_type;
#ifdef _ARROW_EXIST
s3selectEngine::rgw_s3select_api m_rgw_api;
#endif
//a request for range may statisfy by several calls to send_response_date;
size_t m_request_range;
std::string requested_buffer;
std::string range_req_str;
std::function<int(std::string&)> fp_result_header_format;
std::function<int(std::string&)> fp_s3select_result_format;
std::function<void(const char*)> fp_debug_mesg;
std::function<void(void)> fp_chunked_transfer_encoding;
int m_header_size;
public:
unsigned int chunk_number;
size_t m_requested_range;
size_t m_scan_offset;
bool m_skip_next_chunk;
bool m_is_trino_request;
RGWSelectObj_ObjStore_S3();
virtual ~RGWSelectObj_ObjStore_S3();
virtual int send_response_data(bufferlist& bl, off_t ofs, off_t len) override;
virtual int get_params(optional_yield y) override;
virtual void execute(optional_yield) override;
private:
int csv_processing(bufferlist& bl, off_t ofs, off_t len);
int parquet_processing(bufferlist& bl, off_t ofs, off_t len);
int json_processing(bufferlist& bl, off_t ofs, off_t len);
int run_s3select_on_csv(const char* query, const char* input, size_t input_length);
int run_s3select_on_parquet(const char* query);
int run_s3select_on_json(const char* query, const char* input, size_t input_length);
int extract_by_tag(std::string input, std::string tag_name, std::string& result);
void convert_escape_seq(std::string& esc);
int handle_aws_cli_parameters(std::string& sql_query);
int range_request(int64_t start, int64_t len, void*, optional_yield);
size_t get_obj_size();
std::function<int(int64_t, int64_t, void*, optional_yield*)> fp_range_req;
std::function<size_t(void)> fp_get_obj_size;
void shape_chunk_per_trino_requests(const char*, off_t& ofs, off_t& len);
};
| 6,863 | 25.501931 | 168 |
h
|
null |
ceph-main/src/rgw/rgw_sal.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2019 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <errno.h>
#include <stdlib.h>
#include <system_error>
#include <unistd.h>
#include <sstream>
#include "common/errno.h"
#include "rgw_sal.h"
#include "rgw_sal_rados.h"
#include "driver/rados/config/store.h"
#include "driver/json_config/store.h"
#include "rgw_d3n_datacache.h"
#ifdef WITH_RADOSGW_DBSTORE
#include "rgw_sal_dbstore.h"
#include "driver/dbstore/config/store.h"
#endif
#ifdef WITH_RADOSGW_D4N
#include "driver/d4n/rgw_sal_d4n.h"
#endif
#ifdef WITH_RADOSGW_MOTR
#include "rgw_sal_motr.h"
#endif
#ifdef WITH_RADOSGW_DAOS
#include "rgw_sal_daos.h"
#endif
#define dout_subsys ceph_subsys_rgw
extern "C" {
extern rgw::sal::Driver* newRadosStore(void);
#ifdef WITH_RADOSGW_DBSTORE
extern rgw::sal::Driver* newDBStore(CephContext *cct);
#endif
#ifdef WITH_RADOSGW_MOTR
extern rgw::sal::Driver* newMotrStore(CephContext *cct);
#endif
#ifdef WITH_RADOSGW_DAOS
extern rgw::sal::Driver* newDaosStore(CephContext *cct);
#endif
extern rgw::sal::Driver* newBaseFilter(rgw::sal::Driver* next);
#ifdef WITH_RADOSGW_D4N
extern rgw::sal::Driver* newD4NFilter(rgw::sal::Driver* next);
#endif
}
RGWObjState::RGWObjState() {
}
RGWObjState::~RGWObjState() {
}
RGWObjState::RGWObjState(const RGWObjState& rhs) : obj (rhs.obj) {
is_atomic = rhs.is_atomic;
has_attrs = rhs.has_attrs;
exists = rhs.exists;
size = rhs.size;
accounted_size = rhs.accounted_size;
mtime = rhs.mtime;
epoch = rhs.epoch;
if (rhs.obj_tag.length()) {
obj_tag = rhs.obj_tag;
}
if (rhs.tail_tag.length()) {
tail_tag = rhs.tail_tag;
}
write_tag = rhs.write_tag;
fake_tag = rhs.fake_tag;
shadow_obj = rhs.shadow_obj;
has_data = rhs.has_data;
if (rhs.data.length()) {
data = rhs.data;
}
prefetch_data = rhs.prefetch_data;
keep_tail = rhs.keep_tail;
is_olh = rhs.is_olh;
objv_tracker = rhs.objv_tracker;
pg_ver = rhs.pg_ver;
compressed = rhs.compressed;
}
rgw::sal::Driver* DriverManager::init_storage_provider(const DoutPrefixProvider* dpp,
CephContext* cct,
const Config& cfg,
bool use_gc_thread,
bool use_lc_thread,
bool quota_threads,
bool run_sync_thread,
bool run_reshard_thread,
bool run_notification_thread,
bool use_cache,
bool use_gc, optional_yield y)
{
rgw::sal::Driver* driver{nullptr};
if (cfg.store_name.compare("rados") == 0) {
driver = newRadosStore();
RGWRados* rados = static_cast<rgw::sal::RadosStore* >(driver)->getRados();
if ((*rados).set_use_cache(use_cache)
.set_use_datacache(false)
.set_use_gc(use_gc)
.set_run_gc_thread(use_gc_thread)
.set_run_lc_thread(use_lc_thread)
.set_run_quota_threads(quota_threads)
.set_run_sync_thread(run_sync_thread)
.set_run_reshard_thread(run_reshard_thread)
.set_run_notification_thread(run_notification_thread)
.init_begin(cct, dpp) < 0) {
delete driver;
return nullptr;
}
if (driver->initialize(cct, dpp) < 0) {
delete driver;
return nullptr;
}
if (rados->init_complete(dpp, y) < 0) {
delete driver;
return nullptr;
}
}
else if (cfg.store_name.compare("d3n") == 0) {
driver = new rgw::sal::RadosStore();
RGWRados* rados = new D3nRGWDataCache<RGWRados>;
dynamic_cast<rgw::sal::RadosStore*>(driver)->setRados(rados);
rados->set_store(static_cast<rgw::sal::RadosStore* >(driver));
if ((*rados).set_use_cache(use_cache)
.set_use_datacache(true)
.set_run_gc_thread(use_gc_thread)
.set_run_lc_thread(use_lc_thread)
.set_run_quota_threads(quota_threads)
.set_run_sync_thread(run_sync_thread)
.set_run_reshard_thread(run_reshard_thread)
.set_run_notification_thread(run_notification_thread)
.init_begin(cct, dpp) < 0) {
delete driver;
return nullptr;
}
if (driver->initialize(cct, dpp) < 0) {
delete driver;
return nullptr;
}
if (rados->init_complete(dpp, y) < 0) {
delete driver;
return nullptr;
}
lsubdout(cct, rgw, 1) << "rgw_d3n: rgw_d3n_l1_local_datacache_enabled=" <<
cct->_conf->rgw_d3n_l1_local_datacache_enabled << dendl;
lsubdout(cct, rgw, 1) << "rgw_d3n: rgw_d3n_l1_datacache_persistent_path='" <<
cct->_conf->rgw_d3n_l1_datacache_persistent_path << "'" << dendl;
lsubdout(cct, rgw, 1) << "rgw_d3n: rgw_d3n_l1_datacache_size=" <<
cct->_conf->rgw_d3n_l1_datacache_size << dendl;
lsubdout(cct, rgw, 1) << "rgw_d3n: rgw_d3n_l1_evict_cache_on_start=" <<
cct->_conf->rgw_d3n_l1_evict_cache_on_start << dendl;
lsubdout(cct, rgw, 1) << "rgw_d3n: rgw_d3n_l1_fadvise=" <<
cct->_conf->rgw_d3n_l1_fadvise << dendl;
lsubdout(cct, rgw, 1) << "rgw_d3n: rgw_d3n_l1_eviction_policy=" <<
cct->_conf->rgw_d3n_l1_eviction_policy << dendl;
}
#ifdef WITH_RADOSGW_DBSTORE
else if (cfg.store_name.compare("dbstore") == 0) {
driver = newDBStore(cct);
if ((*(rgw::sal::DBStore*)driver).set_run_lc_thread(use_lc_thread)
.initialize(cct, dpp) < 0) {
delete driver;
return nullptr;
}
}
#endif
#ifdef WITH_RADOSGW_MOTR
else if (cfg.store_name.compare("motr") == 0) {
driver = newMotrStore(cct);
if (driver == nullptr) {
ldpp_dout(dpp, 0) << "newMotrStore() failed!" << dendl;
return driver;
}
((rgw::sal::MotrStore *)driver)->init_metadata_cache(dpp, cct);
return store;
}
#endif
#ifdef WITH_RADOSGW_DAOS
else if (cfg.store_name.compare("daos") == 0) {
driver = newDaosStore(cct);
if (driver == nullptr) {
ldpp_dout(dpp, 0) << "newDaosStore() failed!" << dendl;
return driver;
}
int ret = driver->initialize(cct, dpp);
if (ret != 0) {
ldpp_dout(dpp, 20) << "ERROR: store->initialize() failed: " << ret << dendl;
delete driver;
return nullptr;
}
}
#endif
if (cfg.filter_name.compare("base") == 0) {
rgw::sal::Driver* next = driver;
driver = newBaseFilter(next);
if (driver->initialize(cct, dpp) < 0) {
delete driver;
delete next;
return nullptr;
}
}
#ifdef WITH_RADOSGW_D4N
else if (cfg.filter_name.compare("d4n") == 0) {
rgw::sal::Driver* next = driver;
driver = newD4NFilter(next);
if (driver->initialize(cct, dpp) < 0) {
delete driver;
delete next;
return nullptr;
}
}
#endif
return driver;
}
rgw::sal::Driver* DriverManager::init_raw_storage_provider(const DoutPrefixProvider* dpp, CephContext* cct, const Config& cfg)
{
rgw::sal::Driver* driver = nullptr;
if (cfg.store_name.compare("rados") == 0) {
driver = newRadosStore();
RGWRados* rados = static_cast<rgw::sal::RadosStore* >(driver)->getRados();
rados->set_context(cct);
int ret = rados->init_svc(true, dpp);
if (ret < 0) {
ldout(cct, 0) << "ERROR: failed to init services (ret=" << cpp_strerror(-ret) << ")" << dendl;
delete driver;
return nullptr;
}
if (rados->init_rados() < 0) {
delete driver;
return nullptr;
}
if (driver->initialize(cct, dpp) < 0) {
delete driver;
return nullptr;
}
} else if (cfg.store_name.compare("dbstore") == 0) {
#ifdef WITH_RADOSGW_DBSTORE
driver = newDBStore(cct);
if ((*(rgw::sal::DBStore*)driver).initialize(cct, dpp) < 0) {
delete driver;
return nullptr;
}
#else
driver = nullptr;
#endif
} else if (cfg.store_name.compare("motr") == 0) {
#ifdef WITH_RADOSGW_MOTR
driver = newMotrStore(cct);
#else
driver = nullptr;
#endif
} else if (cfg.store_name.compare("daos") == 0) {
#ifdef WITH_RADOSGW_DAOS
driver = newDaosStore(cct);
if (driver->initialize(cct, dpp) < 0) {
delete driver;
return nullptr;
}
#else
driver = nullptr;
#endif
}
if (cfg.filter_name.compare("base") == 0) {
rgw::sal::Driver* next = driver;
driver = newBaseFilter(next);
if (driver->initialize(cct, dpp) < 0) {
delete driver;
delete next;
return nullptr;
}
}
return driver;
}
void DriverManager::close_storage(rgw::sal::Driver* driver)
{
if (!driver)
return;
driver->finalize();
delete driver;
}
DriverManager::Config DriverManager::get_config(bool admin, CephContext* cct)
{
DriverManager::Config cfg;
// Get the store backend
const auto& config_store = g_conf().get_val<std::string>("rgw_backend_store");
if (config_store == "rados") {
cfg.store_name = "rados";
/* Check to see if d3n is configured, but only for non-admin */
const auto& d3n = g_conf().get_val<bool>("rgw_d3n_l1_local_datacache_enabled");
if (!admin && d3n) {
if (g_conf().get_val<Option::size_t>("rgw_max_chunk_size") !=
g_conf().get_val<Option::size_t>("rgw_obj_stripe_size")) {
lsubdout(cct, rgw_datacache, 0) << "rgw_d3n: WARNING: D3N DataCache disabling (D3N requires that the chunk_size equals stripe_size)" << dendl;
} else if (!g_conf().get_val<bool>("rgw_beast_enable_async")) {
lsubdout(cct, rgw_datacache, 0) << "rgw_d3n: WARNING: D3N DataCache disabling (D3N requires yield context - rgw_beast_enable_async=true)" << dendl;
} else {
cfg.store_name = "d3n";
}
}
}
#ifdef WITH_RADOSGW_DBSTORE
else if (config_store == "dbstore") {
cfg.store_name = "dbstore";
}
#endif
#ifdef WITH_RADOSGW_MOTR
else if (config_store == "motr") {
cfg.store_name = "motr";
}
#endif
#ifdef WITH_RADOSGW_DAOS
else if (config_store == "daos") {
cfg.store_name = "daos";
}
#endif
// Get the filter
cfg.filter_name = "none";
const auto& config_filter = g_conf().get_val<std::string>("rgw_filter");
if (config_filter == "base") {
cfg.filter_name = "base";
}
#ifdef WITH_RADOSGW_D4N
else if (config_filter == "d4n") {
cfg.filter_name= "d4n";
}
#endif
return cfg;
}
auto DriverManager::create_config_store(const DoutPrefixProvider* dpp,
std::string_view type)
-> std::unique_ptr<rgw::sal::ConfigStore>
{
try {
if (type == "rados") {
return rgw::rados::create_config_store(dpp);
#ifdef WITH_RADOSGW_DBSTORE
} else if (type == "dbstore") {
const auto uri = g_conf().get_val<std::string>("dbstore_config_uri");
return rgw::dbstore::create_config_store(dpp, uri);
#endif
} else if (type == "json") {
auto filename = g_conf().get_val<std::string>("rgw_json_config");
return rgw::sal::create_json_config_store(dpp, filename);
} else {
ldpp_dout(dpp, -1) << "ERROR: unrecognized config store type '"
<< type << "'" << dendl;
return nullptr;
}
} catch (const std::exception& e) {
ldpp_dout(dpp, -1) << "ERROR: failed to initialize config store '"
<< type << "': " << e.what() << dendl;
}
return nullptr;
}
namespace rgw::sal {
int Object::range_to_ofs(uint64_t obj_size, int64_t &ofs, int64_t &end)
{
if (ofs < 0) {
ofs += obj_size;
if (ofs < 0)
ofs = 0;
end = obj_size - 1;
} else if (end < 0) {
end = obj_size - 1;
}
if (obj_size > 0) {
if (ofs >= (off_t)obj_size) {
return -ERANGE;
}
if (end >= (off_t)obj_size) {
end = obj_size - 1;
}
}
return 0;
}
} // namespace rgw::sal
| 11,881 | 26.761682 | 149 |
cc
|
null |
ceph-main/src/rgw/rgw_sal.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2019 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#pragma once
#include "rgw_sal_fwd.h"
#include "rgw_lua.h"
#include "rgw_user.h"
#include "rgw_notify_event_type.h"
#include "common/tracer.h"
#include "rgw_datalog_notify.h"
#include "include/random.h"
class RGWRESTMgr;
class RGWAccessListFilter;
class RGWLC;
struct rgw_user_bucket;
class RGWUsageBatch;
class RGWCoroutinesManagerRegistry;
class RGWBucketSyncPolicyHandler;
using RGWBucketSyncPolicyHandlerRef = std::shared_ptr<RGWBucketSyncPolicyHandler>;
class RGWDataSyncStatusManager;
class RGWSyncModuleInstance;
typedef std::shared_ptr<RGWSyncModuleInstance> RGWSyncModuleInstanceRef;
class RGWCompressionInfo;
struct rgw_pubsub_topics;
struct rgw_pubsub_bucket_topics;
using RGWBucketListNameFilter = std::function<bool (const std::string&)>;
namespace rgw {
class Aio;
namespace IAM { struct Policy; }
}
class RGWGetDataCB {
public:
virtual int handle_data(bufferlist& bl, off_t bl_ofs, off_t bl_len) = 0;
RGWGetDataCB() {}
virtual ~RGWGetDataCB() {}
};
struct RGWUsageIter {
std::string read_iter;
uint32_t index;
RGWUsageIter() : index(0) {}
};
/**
* @struct RGWClusterStat
* Cluster-wide usage information
*/
struct RGWClusterStat {
/// total device size
uint64_t kb;
/// total used
uint64_t kb_used;
/// total available/free
uint64_t kb_avail;
/// number of objects
uint64_t num_objects;
};
class RGWGetBucketStats_CB : public RefCountedObject {
protected:
rgw_bucket bucket;
std::map<RGWObjCategory, RGWStorageStats>* stats;
public:
explicit RGWGetBucketStats_CB(const rgw_bucket& _bucket) : bucket(_bucket), stats(NULL) {}
~RGWGetBucketStats_CB() override {}
virtual void handle_response(int r) = 0;
virtual void set_response(std::map<RGWObjCategory, RGWStorageStats>* _stats) {
stats = _stats;
}
};
class RGWGetUserStats_CB : public RefCountedObject {
protected:
rgw_user user;
RGWStorageStats stats;
public:
explicit RGWGetUserStats_CB(const rgw_user& _user) : user(_user) {}
~RGWGetUserStats_CB() override {}
virtual void handle_response(int r) = 0;
virtual void set_response(RGWStorageStats& _stats) {
stats = _stats;
}
};
struct RGWObjState {
rgw_obj obj;
bool is_atomic{false};
bool has_attrs{false};
bool exists{false};
uint64_t size{0}; //< size of raw object
uint64_t accounted_size{0}; //< size before compression, encryption
ceph::real_time mtime;
uint64_t epoch{0};
bufferlist obj_tag;
bufferlist tail_tag;
std::string write_tag;
bool fake_tag{false};
std::string shadow_obj;
bool has_data{false};
bufferlist data;
bool prefetch_data{false};
bool keep_tail{false};
bool is_olh{false};
bufferlist olh_tag;
uint64_t pg_ver{false};
uint32_t zone_short_id{0};
bool compressed{false};
/* important! don't forget to update copy constructor */
RGWObjVersionTracker objv_tracker;
std::map<std::string, ceph::buffer::list> attrset;
RGWObjState();
RGWObjState(const RGWObjState& rhs);
~RGWObjState();
bool get_attr(std::string name, bufferlist& dest) {
auto iter = attrset.find(name);
if (iter != attrset.end()) {
dest = iter->second;
return true;
}
return false;
}
};
/**
* @defgroup RGWSAL RGW Store Abstraction Layer
*
* The Store Abstraction Layer is an API that separates the top layer of RGW that
* handles client protocols (such as S3 or Swift) from the bottom layer of RGW that
* interacts with a backing store. It allows the creation of multiple backing stores
* that can co-exist with a single RGW instance, and allows the creation of stacking
* layers of translators that can modify operations as they pass down the stack.
* Examples of translators might be a cache layer, a duplication layer that copies
* operations to multiple stores, or a policy layer that sends some operations to one
* store and some to another.
*
* The basic unit of a SAL implementation is the Store. Whether an actual backing store
* or a translator, there will be a Store implementation that represents it. Examples
* are the RadosStore that communicates via RADOS with a Ceph cluster, and the DBStore
* that uses a SQL db (such as SQLite3) as a backing store. There is a singleton
* instance of each Store.
*
* Data within RGW is owned by a User. The User is the unit of authentication and
* access control.
*
* Data within RGW is stored as an Object. Each Object is a single chunk of data, owned
* by a single User, contained within a single Bucket. It has metadata associated with
* it, such as size, owner, and so on, and a set of key-value attributes that can
* contain anything needed by the top half.
*
* Data with RGW is organized into Buckets. Each Bucket is owned by a User, and
* contains Objects. There is a single, flat layer of Buckets, there is no hierarchy,
* and each Object is contained in a single Bucket.
*
* Instantiations of SAL classes are done as unique pointers, using std::unique_ptr.
* Instances of these classes are acquired via getters, and it's up to the caller to
* manage the lifetime.
*
* @note Anything using RGWObjContext is subject to change, as that type will not be
* used in the final API.
* @{
*/
/**
* @file rgw_sal.h
* @brief Base abstractions and API for SAL
*/
namespace rgw { namespace sal {
/**
* @addtogroup RGWSAL
* @{
*/
#define RGW_SAL_VERSION 1
struct MPSerializer;
class GCChain;
class RGWOIDCProvider;
class RGWRole;
enum AttrsMod {
ATTRSMOD_NONE = 0,
ATTRSMOD_REPLACE = 1,
ATTRSMOD_MERGE = 2
};
// a simple streaming data processing abstraction
/**
* @brief A simple streaming data processing abstraction
*/
class DataProcessor {
public:
virtual ~DataProcessor() {}
/**
* @brief Consume a bufferlist in its entirety at the given object offset.
*
* An empty bufferlist is given to request that any buffered data be flushed, though this doesn't
* wait for completions
*/
virtual int process(bufferlist&& data, uint64_t offset) = 0;
};
/**
* @brief a data consumer that writes an object in a bucket
*/
class ObjectProcessor : public DataProcessor {
public:
/** prepare to start processing object data */
virtual int prepare(optional_yield y) = 0;
/** complete the operation and make its result visible to clients */
virtual int complete(size_t accounted_size, const std::string& etag,
ceph::real_time *mtime, ceph::real_time set_mtime,
std::map<std::string, bufferlist>& attrs,
ceph::real_time delete_at,
const char *if_match, const char *if_nomatch,
const std::string *user_data,
rgw_zone_set *zones_trace, bool *canceled,
optional_yield y) = 0;
};
/** A list of key-value attributes */
using Attrs = std::map<std::string, ceph::buffer::list>;
/**
* @brief Base singleton representing a Store or Filter
*
* The Driver is the base abstraction of the SAL layer. It represents a base storage
* mechanism, or a intermediate stacking layer. There is a single instance of a given
* Driver per RGW, and this Driver mediates all access to it's backing.
*
* A Driver contains, loosely, @a User, @a Bucket, and @a Object entities. The @a Object
* contains data, and it's associated metadata. The @a Bucket contains Objects, and
* metadata about the bucket. Both Buckets and Objects are owned by a @a User, which is
* the basic unit of access control.
*
* A Driver also has metadata and some global responsibilities. For example, a driver is
* responsible for managing the LifeCycle activities for it's data.
*/
class Driver {
public:
Driver() {}
virtual ~Driver() = default;
/** Post-creation initialization of driver */
virtual int initialize(CephContext *cct, const DoutPrefixProvider *dpp) = 0;
/** Name of this driver provider (e.g., "rados") */
virtual const std::string get_name() const = 0;
/** Get cluster unique identifier */
virtual std::string get_cluster_id(const DoutPrefixProvider* dpp, optional_yield y) = 0;
/** Get a User from a rgw_user. Does not query driver for user info, so quick */
virtual std::unique_ptr<User> get_user(const rgw_user& u) = 0;
/** Lookup a User by access key. Queries driver for user info. */
virtual int get_user_by_access_key(const DoutPrefixProvider* dpp, const std::string& key, optional_yield y, std::unique_ptr<User>* user) = 0;
/** Lookup a User by email address. Queries driver for user info. */
virtual int get_user_by_email(const DoutPrefixProvider* dpp, const std::string& email, optional_yield y, std::unique_ptr<User>* user) = 0;
/** Lookup a User by swift username. Queries driver for user info. */
virtual int get_user_by_swift(const DoutPrefixProvider* dpp, const std::string& user_str, optional_yield y, std::unique_ptr<User>* user) = 0;
/** Get a basic Object. This Object is not looked up, and is incomplete, since is
* does not have a bucket. This should only be used when an Object is needed before
* 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 int get_bucket(User* u, const RGWBucketInfo& i, std::unique_ptr<Bucket>* bucket) = 0;
/** Lookup a Bucket by key. Queries driver for bucket info. */
virtual int get_bucket(const DoutPrefixProvider* dpp, User* u, const rgw_bucket& b, std::unique_ptr<Bucket>* bucket, optional_yield y) = 0;
/** Lookup a Bucket by name. Queries driver for bucket info. */
virtual int get_bucket(const DoutPrefixProvider* dpp, User* u, const std::string& tenant, const std::string& name, std::unique_ptr<Bucket>* bucket, optional_yield y) = 0;
/** For multisite, this driver is the zone's master */
virtual bool is_meta_master() = 0;
/** For multisite, forward an OP to the zone's master */
virtual int forward_request_to_master(const DoutPrefixProvider *dpp, User* user, obj_version* objv,
bufferlist& in_data, JSONParser* jp, req_info& info,
optional_yield y) = 0;
virtual int forward_iam_request_to_master(const DoutPrefixProvider *dpp, const RGWAccessKey& key, obj_version* objv,
bufferlist& in_data,
RGWXMLDecoder::XMLParser* parser, req_info& info,
optional_yield y) = 0;
/** Get zone info for this driver */
virtual Zone* get_zone() = 0;
/** Get a unique ID specific to this zone. */
virtual std::string zone_unique_id(uint64_t unique_num) = 0;
/** Get a unique Swift transaction ID specific to this zone */
virtual std::string zone_unique_trans_id(const uint64_t unique_num) = 0;
/** Lookup a zonegroup by ID */
virtual int get_zonegroup(const std::string& id, std::unique_ptr<ZoneGroup>* zonegroup) = 0;
/** List all zones in all zone groups by ID */
virtual int list_all_zones(const DoutPrefixProvider* dpp, std::list<std::string>& zone_ids) = 0;
/** Get statistics about the cluster represented by this driver */
virtual int cluster_stat(RGWClusterStat& stats) = 0;
/** Get a @a Lifecycle object. Used to manage/run lifecycle transitions */
virtual std::unique_ptr<Lifecycle> get_lifecycle(void) = 0;
/** Get a @a Notification object. Used to communicate with non-RGW daemons, such as
* management/tracking software */
/** RGWOp variant */
virtual std::unique_ptr<Notification> get_notification(rgw::sal::Object* obj, rgw::sal::Object* src_obj, req_state* s,
rgw::notify::EventType event_type, optional_yield y, const std::string* object_name=nullptr) = 0;
/** No-req_state variant (e.g., rgwlc) */
virtual std::unique_ptr<Notification> get_notification(
const DoutPrefixProvider* dpp, rgw::sal::Object* obj, rgw::sal::Object* src_obj,
rgw::notify::EventType event_type, rgw::sal::Bucket* _bucket, std::string& _user_id, std::string& _user_tenant,
std::string& _req_id, optional_yield y) = 0;
/** Read the topic config entry into @a data and (optionally) @a objv_tracker */
virtual int read_topics(const std::string& tenant, rgw_pubsub_topics& topics, RGWObjVersionTracker* objv_tracker,
optional_yield y, const DoutPrefixProvider *dpp) = 0;
/** Write @a info and (optionally) @a objv_tracker into the config */
virtual int write_topics(const std::string& tenant, const rgw_pubsub_topics& topics, RGWObjVersionTracker* objv_tracker,
optional_yield y, const DoutPrefixProvider *dpp) = 0;
/** Remove the topic config, optionally a specific version */
virtual int remove_topics(const std::string& tenant, RGWObjVersionTracker* objv_tracker,
optional_yield y,const DoutPrefixProvider *dpp) = 0;
/** Get access to the lifecycle management thread */
virtual RGWLC* get_rgwlc(void) = 0;
/** Get access to the coroutine registry. Used to create new coroutine managers */
virtual RGWCoroutinesManagerRegistry* get_cr_registry() = 0;
/** Log usage data to the driver. Usage data is things like bytes sent/received and
* op count */
virtual int log_usage(const DoutPrefixProvider *dpp, std::map<rgw_user_bucket, RGWUsageBatch>& usage_info, optional_yield y) = 0;
/** Log OP data to the driver. Data is opaque to SAL */
virtual int log_op(const DoutPrefixProvider *dpp, std::string& oid, bufferlist& bl) = 0;
/** Register this driver to the service map. Somewhat Rados specific; may be removed*/
virtual int register_to_service_map(const DoutPrefixProvider *dpp, const std::string& daemon_type,
const std::map<std::string, std::string>& meta) = 0;
/** Get default quota info. Used as fallback if a user or bucket has no quota set*/
virtual void get_quota(RGWQuota& quota) = 0;
/** Get global rate limit configuration*/
virtual void get_ratelimit(RGWRateLimitInfo& bucket_ratelimit, RGWRateLimitInfo& user_ratelimit, RGWRateLimitInfo& anon_ratelimit) = 0;
/** Enable or disable a set of bucket. e.g. if a User is suspended */
virtual int set_buckets_enabled(const DoutPrefixProvider* dpp, std::vector<rgw_bucket>& buckets, bool enabled, optional_yield y) = 0;
/** Get a new request ID */
virtual uint64_t get_new_req_id() = 0;
/** Get a handler for bucket sync policy. */
virtual int get_sync_policy_handler(const DoutPrefixProvider* dpp,
std::optional<rgw_zone_id> zone,
std::optional<rgw_bucket> bucket,
RGWBucketSyncPolicyHandlerRef* phandler,
optional_yield y) = 0;
/** Get a status manager for bucket sync */
virtual RGWDataSyncStatusManager* get_data_sync_manager(const rgw_zone_id& source_zone) = 0;
/** Wake up sync threads for bucket metadata sync */
virtual void wakeup_meta_sync_shards(std::set<int>& shard_ids) = 0;
/** Wake up sync threads for bucket data sync */
virtual void wakeup_data_sync_shards(const DoutPrefixProvider *dpp, const rgw_zone_id& source_zone, boost::container::flat_map<int, boost::container::flat_set<rgw_data_notify_entry>>& shard_ids) = 0;
/** Clear all usage statistics globally */
virtual int clear_usage(const DoutPrefixProvider *dpp, optional_yield y) = 0;
/** Get usage statistics for all users and buckets */
virtual int read_all_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch,
uint32_t max_entries, bool* is_truncated,
RGWUsageIter& usage_iter,
std::map<rgw_user_bucket, rgw_usage_log_entry>& usage) = 0;
/** Trim usage log for all users and buckets */
virtual int trim_all_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch, optional_yield y) = 0;
/** Get a configuration value for the given name */
virtual int get_config_key_val(std::string name, bufferlist* bl) = 0;
/** Start a metadata listing of the given section */
virtual int meta_list_keys_init(const DoutPrefixProvider *dpp, const std::string& section, const std::string& marker, void** phandle) = 0;
/** Get the next key from a metadata list */
virtual int meta_list_keys_next(const DoutPrefixProvider *dpp, void* handle, int max, std::list<std::string>& keys, bool* truncated) = 0;
/** Complete a metadata listing */
virtual void meta_list_keys_complete(void* handle) = 0;
/** Get the marker associated with the current metadata listing */
virtual std::string meta_get_marker(void* handle) = 0;
/** Remove a specific metadata key */
virtual int meta_remove(const DoutPrefixProvider* dpp, std::string& metadata_key, optional_yield y) = 0;
/** Get an instance of the Sync module for bucket sync */
virtual const RGWSyncModuleInstanceRef& get_sync_module() = 0;
/** Get the ID of the current host */
virtual std::string get_host_id() = 0;
/** Get a Lua script manager for running lua scripts */
virtual std::unique_ptr<LuaManager> get_lua_manager() = 0;
/** Get an IAM Role by name etc. */
virtual std::unique_ptr<RGWRole> get_role(std::string name,
std::string tenant,
std::string path="",
std::string trust_policy="",
std::string max_session_duration_str="",
std::multimap<std::string,std::string> tags={}) = 0;
/** Get an IAM Role by ID */
virtual std::unique_ptr<RGWRole> get_role(std::string id) = 0;
virtual std::unique_ptr<RGWRole> get_role(const RGWRoleInfo& info) = 0;
/** Get all IAM Roles optionally filtered by path */
virtual int get_roles(const DoutPrefixProvider *dpp,
optional_yield y,
const std::string& path_prefix,
const std::string& tenant,
std::vector<std::unique_ptr<RGWRole>>& roles) = 0;
/** Get an empty Open ID Connector provider */
virtual std::unique_ptr<RGWOIDCProvider> get_oidc_provider() = 0;
/** Get all Open ID Connector providers, optionally filtered by tenant */
virtual int get_oidc_providers(const DoutPrefixProvider *dpp,
const std::string& tenant,
std::vector<std::unique_ptr<RGWOIDCProvider>>& providers, optional_yield y) = 0;
/** Get a Writer that appends to an object */
virtual std::unique_ptr<Writer> get_append_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
const std::string& unique_tag,
uint64_t position,
uint64_t *cur_accounted_size) = 0;
/** Get a Writer that atomically writes an entire object */
virtual std::unique_ptr<Writer> get_atomic_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag) = 0;
/** Get the compression type of a placement rule */
virtual const std::string& get_compression_type(const rgw_placement_rule& rule) = 0;
/** Check to see if this placement rule is valid */
virtual bool valid_placement(const rgw_placement_rule& rule) = 0;
/** Clean up a driver for termination */
virtual void finalize(void) = 0;
/** Get the Ceph context associated with this driver. May be removed. */
virtual CephContext* ctx(void) = 0;
/** Register admin APIs unique to this driver */
virtual void register_admin_apis(RGWRESTMgr* mgr) = 0;
};
/**
* @brief User abstraction
*
* This represents a user. In general, there will be a @a User associated with an OP
* (the user performing the OP), and potentially several others acting as owners.
* Lifetime of a User is a bit tricky , since it must last as long as any Buckets
* associated with it. A User has associated metadata, including a set of key/value
* attributes, and statistics (including usage) about the User.
*/
class User {
public:
User() {}
virtual ~User() = default;
/** Clone a copy of this user. Used when modification is necessary of the copy */
virtual std::unique_ptr<User> clone() = 0;
/** List the buckets owned by a user */
virtual int list_buckets(const DoutPrefixProvider* dpp,
const std::string& marker, const std::string& end_marker,
uint64_t max, bool need_stats, BucketList& buckets,
optional_yield y) = 0;
/** Create a new bucket owned by this user. Creates in the backing store, not just the instantiation. */
virtual int create_bucket(const DoutPrefixProvider* dpp,
const rgw_bucket& b,
const std::string& zonegroup_id,
rgw_placement_rule& placement_rule,
std::string& swift_ver_location,
const RGWQuotaInfo* pquota_info,
const RGWAccessControlPolicy& policy,
Attrs& attrs,
RGWBucketInfo& info,
obj_version& ep_objv,
bool exclusive,
bool obj_lock_enabled,
bool* existed,
req_info& req_info,
std::unique_ptr<Bucket>* bucket,
optional_yield y) = 0;
/** Get the display name for this User */
virtual std::string& get_display_name() = 0;
/** Get the tenant name for this User */
virtual const std::string& get_tenant() = 0;
/** Set the tenant name for this User */
virtual void set_tenant(std::string& _t) = 0;
/** Get the namespace for this User */
virtual const std::string& get_ns() = 0;
/** Set the namespace for this User */
virtual void set_ns(std::string& _ns) = 0;
/** Clear the namespace for this User */
virtual void clear_ns() = 0;
/** Get the full ID for this User */
virtual const rgw_user& get_id() const = 0;
/** Get the type of this User */
virtual uint32_t get_type() const = 0;
/** Get the maximum number of buckets allowed for this User */
virtual int32_t get_max_buckets() const = 0;
/** Set the maximum number of buckets allowed for this User */
virtual void set_max_buckets(int32_t _max_buckets) = 0;
/** Set quota info */
virtual void set_info(RGWQuotaInfo& _quota) = 0;
/** Get the capabilities for this User */
virtual const RGWUserCaps& get_caps() const = 0;
/** Get the version tracker for this User */
virtual RGWObjVersionTracker& get_version_tracker() = 0;
/** Get the cached attributes for this User */
virtual Attrs& get_attrs() = 0;
/** Set the cached attributes fro this User */
virtual void set_attrs(Attrs& _attrs) = 0;
/** Check if a User is empty */
virtual bool empty() const = 0;
/** Check if a User pointer is empty */
static bool empty(const User* u) { return (!u || u->empty()); }
/** Check if a User unique_pointer is empty */
static bool empty(const std::unique_ptr<User>& u) { return (!u || u->empty()); }
/** Read the User attributes from the backing Store */
virtual int read_attrs(const DoutPrefixProvider* dpp, optional_yield y) = 0;
/** Set the attributes in attrs, leaving any other existing attrs set, and
* write them to the backing store; a merge operation */
virtual int merge_and_store_attrs(const DoutPrefixProvider* dpp, Attrs& new_attrs, optional_yield y) = 0;
/** Read the User stats from the backing Store, synchronous */
virtual int read_stats(const DoutPrefixProvider *dpp,
optional_yield y, RGWStorageStats* stats,
ceph::real_time* last_stats_sync = nullptr,
ceph::real_time* last_stats_update = nullptr) = 0;
/** Read the User stats from the backing Store, asynchronous */
virtual int read_stats_async(const DoutPrefixProvider *dpp, RGWGetUserStats_CB* cb) = 0;
/** Flush accumulated stat changes for this User to the backing store */
virtual int complete_flush_stats(const DoutPrefixProvider *dpp, optional_yield y) = 0;
/** Read detailed usage stats for this User from the backing store */
virtual int read_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch,
uint64_t end_epoch, uint32_t max_entries,
bool* is_truncated, RGWUsageIter& usage_iter,
std::map<rgw_user_bucket, rgw_usage_log_entry>& usage) = 0;
/** Trim User usage stats to the given epoch range */
virtual int trim_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch, optional_yield y) = 0;
/** Load this User from the backing store. requires ID to be set, fills all other fields. */
virtual int load_user(const DoutPrefixProvider* dpp, optional_yield y) = 0;
/** Store this User to the backing store */
virtual int store_user(const DoutPrefixProvider* dpp, optional_yield y, bool exclusive, RGWUserInfo* old_info = nullptr) = 0;
/** Remove this User from the backing store */
virtual int remove_user(const DoutPrefixProvider* dpp, optional_yield y) = 0;
/** Verify multi-factor authentication for this user */
virtual int verify_mfa(const std::string& mfa_str, bool* verified, const DoutPrefixProvider* dpp, optional_yield y) = 0;
/* dang temporary; will be removed when User is complete */
virtual RGWUserInfo& get_info() = 0;
/** Print the User to @a out */
virtual void print(std::ostream& out) const = 0;
friend inline std::ostream& operator<<(std::ostream& out, const User& u) {
u.print(out);
return out;
}
friend inline std::ostream& operator<<(std::ostream& out, const User* u) {
if (!u)
out << "<NULL>";
else
u->print(out);
return out;
}
friend inline std::ostream& operator<<(std::ostream& out, const std::unique_ptr<User>& p) {
out << p.get();
return out;
}
};
/**
* @brief Bucket abstraction
*
* This represents a bucket. A bucket is a container for objects. It is owned by a user, and has
* it's own set of metadata, including a set of key/value attributes. A bucket may not contain
* other buckets, only objects. Buckets have Access Control Lists (ACLs) that control what users
* can access the contents of the bucket, and in what ways.
*/
class Bucket {
public:
/**
* @brief Parameters for a bucket list operation
*/
struct ListParams {
std::string prefix;
std::string delim;
rgw_obj_key marker;
rgw_obj_key end_marker;
std::string ns;
bool enforce_ns{true};
RGWAccessListFilter* access_list_filter{nullptr};
RGWBucketListNameFilter force_check_filter;
bool list_versions{false};
bool allow_unordered{false};
int shard_id{RGW_NO_SHARD};
friend std::ostream& operator<<(std::ostream& out, const ListParams& p) {
out << "rgw::sal::Bucket::ListParams{ prefix=\"" << p.prefix <<
"\", delim=\"" << p.delim <<
"\", marker=\"" << p.marker <<
"\", end_marker=\"" << p.end_marker <<
"\", ns=\"" << p.ns <<
"\", enforce_ns=" << p.enforce_ns <<
", list_versions=" << p.list_versions <<
", allow_unordered=" << p.allow_unordered <<
", shard_id=" << p.shard_id <<
" }";
return out;
}
};
/**
* @brief Results from a bucket list operation
*/
struct ListResults {
std::vector<rgw_bucket_dir_entry> objs;
std::map<std::string, bool> common_prefixes;
bool is_truncated{false};
rgw_obj_key next_marker;
};
Bucket() = default;
virtual ~Bucket() = default;
/** Get an @a Object belonging to this bucket */
virtual std::unique_ptr<Object> get_object(const rgw_obj_key& key) = 0;
/** List the contents of this bucket */
virtual int list(const DoutPrefixProvider* dpp, ListParams&, int, ListResults&, optional_yield y) = 0;
/** Get the cached attributes associated with this bucket */
virtual Attrs& get_attrs(void) = 0;
/** Set the cached attributes on this bucket */
virtual int set_attrs(Attrs a) = 0;
/** Remove this bucket from the backing store */
virtual int remove_bucket(const DoutPrefixProvider* dpp, bool delete_children, bool forward_to_master, req_info* req_info, optional_yield y) = 0;
/** Remove this bucket, bypassing garbage collection. May be removed */
virtual int remove_bucket_bypass_gc(int concurrent_max, bool
keep_index_consistent,
optional_yield y, const
DoutPrefixProvider *dpp) = 0;
/** Get then ACL for this bucket */
virtual RGWAccessControlPolicy& get_acl(void) = 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;
/** Load this bucket from the backing store. Requires the key to be set, fills other fields.
* If @a get_stats is true, then statistics on the bucket are also looked up. */
virtual int load_bucket(const DoutPrefixProvider* dpp, optional_yield y, bool get_stats = false) = 0;
/** Read the bucket stats from the backing Store, synchronous */
virtual int read_stats(const DoutPrefixProvider *dpp,
const bucket_index_layout_generation& idx_layout,
int shard_id, std::string* bucket_ver, std::string* master_ver,
std::map<RGWObjCategory, RGWStorageStats>& stats,
std::string* max_marker = nullptr,
bool* syncstopped = nullptr) = 0;
/** Read the bucket stats from the backing Store, asynchronous */
virtual int read_stats_async(const DoutPrefixProvider *dpp,
const bucket_index_layout_generation& idx_layout,
int shard_id, RGWGetBucketStats_CB* ctx) = 0;
/** Sync this bucket's stats to the owning user's stats in the backing store */
virtual int sync_user_stats(const DoutPrefixProvider *dpp, optional_yield y) = 0;
/** Refresh the metadata stats (size, count, and so on) from the backing store */
virtual int update_container_stats(const DoutPrefixProvider* dpp, optional_yield y) = 0;
/** Check if this bucket needs resharding, and schedule it if it does */
virtual int check_bucket_shards(const DoutPrefixProvider* dpp, 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;
/** 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;
/** Get the owner of this bucket in the form of an ACLOwner object */
virtual ACLOwner get_acl_owner(void) = 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 */
virtual int check_quota(const DoutPrefixProvider *dpp, RGWQuota& quota, uint64_t obj_size, optional_yield y, bool check_size_only = false) = 0;
/** Set the attributes in attrs, leaving any other existing attrs set, and
* write them to the backing store; a merge operation */
virtual int merge_and_store_attrs(const DoutPrefixProvider* dpp, Attrs& new_attrs, optional_yield y) = 0;
/** Try to refresh the cached bucket info from the backing store. Used in
* read-modify-update loop. */
virtual int try_refresh_info(const DoutPrefixProvider* dpp, ceph::real_time* pmtime, optional_yield y) = 0;
/** Read usage information about this bucket from the backing store */
virtual int read_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch, uint32_t max_entries,
bool* is_truncated, RGWUsageIter& usage_iter,
std::map<rgw_user_bucket, rgw_usage_log_entry>& usage) = 0;
/** Trim the usage information to the given epoch range */
virtual int trim_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch, optional_yield y) = 0;
/** Remove objects from the bucket index of this bucket. May be removed from API */
virtual int remove_objs_from_index(const DoutPrefixProvider *dpp, std::list<rgw_obj_index_key>& objs_to_unlink) = 0;
/** Check the state of the bucket index, and get stats from it. May be removed from API */
virtual int check_index(const DoutPrefixProvider *dpp, std::map<RGWObjCategory, RGWStorageStats>& existing_stats, std::map<RGWObjCategory, RGWStorageStats>& calculated_stats) = 0;
/** Rebuild the bucket index. May be removed from API */
virtual int rebuild_index(const DoutPrefixProvider *dpp) = 0;
/** Set a timeout on the check_index() call. May be removed from API */
virtual int set_tag_timeout(const DoutPrefixProvider *dpp, uint64_t timeout) = 0;
/** Remove this specific bucket instance from the backing store. May be removed from API */
virtual int purge_instance(const DoutPrefixProvider* dpp, optional_yield y) = 0;
/** Set the cached object count of this bucket */
virtual void set_count(uint64_t _count) = 0;
/** Set the cached size of this bucket */
virtual void set_size(uint64_t _size) = 0;
/** Check if this instantiation is empty */
virtual bool empty() const = 0;
/** Get the cached name of this bucket */
virtual const std::string& get_name() const = 0;
/** Get the cached tenant of this bucket */
virtual const std::string& get_tenant() const = 0;
/** Get the cached marker of this bucket */
virtual const std::string& get_marker() const = 0;
/** Get the cached ID of this bucket */
virtual const std::string& get_bucket_id() const = 0;
/** Get the cached size of this bucket */
virtual size_t get_size() const = 0;
/** Get the cached rounded size of this bucket */
virtual size_t get_size_rounded() const = 0;
/** Get the cached object count of this bucket */
virtual uint64_t get_count() const = 0;
/** Get the cached placement rule of this bucket */
virtual rgw_placement_rule& get_placement_rule() = 0;
/** Get the cached creation time of this bucket */
virtual ceph::real_time& get_creation_time() = 0;
/** Get the cached modification time of this bucket */
virtual ceph::real_time& get_modification_time() = 0;
/** Get the cached version of this bucket */
virtual obj_version& get_version() = 0;
/** Set the cached version of this bucket */
virtual void set_version(obj_version &ver) = 0;
/** Check if this bucket is versioned */
virtual bool versioned() = 0;
/** Check if this bucket has versioning enabled */
virtual bool versioning_enabled() = 0;
/** Check if a Bucket pointer is empty */
static bool empty(const Bucket* b) { return (!b || b->empty()); }
/** Check if a Bucket unique pointer is empty */
static bool empty(const std::unique_ptr<Bucket>& b) { return (!b || b->empty()); }
/** Clone a copy of this bucket. Used when modification is necessary of the copy */
virtual std::unique_ptr<Bucket> clone() = 0;
/** Create a multipart upload in this bucket */
virtual std::unique_ptr<MultipartUpload> get_multipart_upload(
const std::string& oid,
std::optional<std::string> upload_id=std::nullopt,
ACLOwner owner={}, ceph::real_time mtime=real_clock::now()) = 0;
/** List multipart uploads currently in this bucket */
virtual int list_multiparts(const DoutPrefixProvider *dpp,
const std::string& prefix,
std::string& marker,
const std::string& delim,
const int& max_uploads,
std::vector<std::unique_ptr<MultipartUpload>>& uploads,
std::map<std::string, bool> *common_prefixes,
bool *is_truncated, optional_yield y) = 0;
/** Abort multipart uploads in a bucket */
virtual int abort_multiparts(const DoutPrefixProvider* dpp,
CephContext* cct, optional_yield y) = 0;
/** Read the bucket notification config into @a notifications with and (optionally) @a objv_tracker */
virtual int read_topics(rgw_pubsub_bucket_topics& notifications,
RGWObjVersionTracker* objv_tracker, optional_yield y, const DoutPrefixProvider *dpp) = 0;
/** Write @a notifications with (optionally) @a objv_tracker into the bucket notification config */
virtual int write_topics(const rgw_pubsub_bucket_topics& notifications, RGWObjVersionTracker* objv_tracker,
optional_yield y, const DoutPrefixProvider *dpp) = 0;
/** Remove the bucket notification config with (optionally) @a objv_tracker */
virtual int remove_topics(RGWObjVersionTracker* objv_tracker,
optional_yield y, const DoutPrefixProvider *dpp) = 0;
/* dang - This is temporary, until the API is completed */
virtual rgw_bucket& get_key() = 0;
virtual RGWBucketInfo& get_info() = 0;
/** Print the User to @a out */
virtual void print(std::ostream& out) const = 0;
friend inline std::ostream& operator<<(std::ostream& out, const Bucket& b) {
b.print(out);
return out;
}
friend inline std::ostream& operator<<(std::ostream& out, const Bucket* b) {
if (!b)
out << "<NULL>";
else
b->print(out);
return out;
}
friend inline std::ostream& operator<<(std::ostream& out, const std::unique_ptr<Bucket>& p) {
out << p.get();
return out;
}
virtual bool operator==(const Bucket& b) const = 0;
virtual bool operator!=(const Bucket& b) const = 0;
friend class BucketList;
};
/**
* @brief A list of buckets
*
* This is the result from a bucket listing operation.
*/
class BucketList {
std::map<std::string, std::unique_ptr<Bucket>> buckets;
bool truncated;
public:
BucketList() : buckets(), truncated(false) {}
BucketList(BucketList&& _bl) :
buckets(std::move(_bl.buckets)),
truncated(_bl.truncated)
{ }
BucketList& operator=(const BucketList&) = delete;
BucketList& operator=(BucketList&& _bl) {
for (auto& ent : _bl.buckets) {
buckets.emplace(ent.first, std::move(ent.second));
}
truncated = _bl.truncated;
return *this;
};
/** Get the list of buckets. The list is a map of <bucket-name, Bucket> pairs. */
std::map<std::string, std::unique_ptr<Bucket>>& get_buckets() { return buckets; }
/** True if the list is truncated (that is, there are more buckets to list) */
bool is_truncated(void) const { return truncated; }
/** Set the truncated state of the list */
void set_truncated(bool trunc) { truncated = trunc; }
/** Add a bucket to the list. Takes ownership of the bucket */
void add(std::unique_ptr<Bucket> bucket) {
buckets.emplace(bucket->get_name(), std::move(bucket));
}
/** The number of buckets in this list */
size_t count() const { return buckets.size(); }
/** Clear the list */
void clear(void) {
buckets.clear();
truncated = false;
}
};
/**
* @brief Object abstraction
*
* This represents an Object. An Object is the basic unit of data storage. It
* represents a blob of data, a set of metadata (such as size, owner, ACLs, etc.) and
* a set of key/value attributes. Objects may be versioned. If a versioned object
* is written to, a new object with the same name but a different version is created,
* and the old version of the object is still accessible. If an unversioned object
* is written to, it is replaced, and the old data is not accessible.
*/
class Object {
public:
/**
* @brief Read operation on an Object
*
* This represents a Read operation on an Object. Read operations are optionally
* asynchronous, using the iterate() API.
*/
struct ReadOp {
struct Params {
const ceph::real_time* mod_ptr{nullptr};
const ceph::real_time* unmod_ptr{nullptr};
bool high_precision_time{false};
uint32_t mod_zone_id{0};
uint64_t mod_pg_ver{0};
const char* if_match{nullptr};
const char* if_nomatch{nullptr};
ceph::real_time* lastmod{nullptr};
rgw_obj* target_obj{nullptr}; // XXX dang remove?
} params;
virtual ~ReadOp() = default;
/** Prepare the Read op. Must be called first */
virtual int prepare(optional_yield y, const DoutPrefixProvider* dpp) = 0;
/** Synchronous read. Read from @a ofs to @a end (inclusive)
* into @a bl. Length is `end - ofs + 1`. */
virtual int read(int64_t ofs, int64_t end, bufferlist& bl,
optional_yield y, const DoutPrefixProvider* dpp) = 0;
/** Asynchronous read. Read from @a ofs to @a end (inclusive)
* calling @a cb on each read chunk. Length is `end - ofs +
* 1`. */
virtual int iterate(const DoutPrefixProvider* dpp, int64_t ofs,
int64_t end, RGWGetDataCB* cb, optional_yield y) = 0;
/** Get an attribute by name */
virtual int get_attr(const DoutPrefixProvider* dpp, const char* name, bufferlist& dest, optional_yield y) = 0;
};
/**
* @brief Delete operation on an Object
*
* This deletes an Object from the backing store.
*/
struct DeleteOp {
struct Params {
ACLOwner bucket_owner;
ACLOwner obj_owner;
int versioning_status{0};
uint64_t olh_epoch{0};
std::string marker_version_id;
uint32_t bilog_flags{0};
std::list<rgw_obj_index_key>* remove_objs{nullptr};
ceph::real_time expiration_time;
ceph::real_time unmod_since;
ceph::real_time mtime;
bool high_precision_time{false};
rgw_zone_set* zones_trace{nullptr};
bool abortmp{false};
uint64_t parts_accounted_size{0};
} params;
struct Result {
bool delete_marker{false};
std::string version_id;
} result;
virtual ~DeleteOp() = default;
/** Delete the object */
virtual int delete_obj(const DoutPrefixProvider* dpp, optional_yield y) = 0;
};
Object() {}
virtual ~Object() = default;
/** Shortcut synchronous delete call for common deletes */
virtual int delete_object(const DoutPrefixProvider* dpp,
optional_yield y,
bool prevent_versioning = false) = 0;
/** Copy an this object to another object. */
virtual int copy_object(User* user,
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,
const ceph::real_time* mod_ptr, const ceph::real_time* unmod_ptr,
bool high_precision_time,
const char* if_match, const char* if_nomatch,
AttrsMod attrs_mod, bool copy_if_newer, Attrs& attrs,
RGWObjCategory category, uint64_t olh_epoch,
boost::optional<ceph::real_time> delete_at,
std::string* version_id, std::string* tag, std::string* etag,
void (*progress_cb)(off_t, void *), void* progress_data,
const DoutPrefixProvider* dpp, optional_yield y) = 0;
/** Get the ACL for this object */
virtual RGWAccessControlPolicy& get_acl(void) = 0;
/** Set the ACL for this object */
virtual int set_acl(const RGWAccessControlPolicy& acl) = 0;
/** Mark further operations on this object as being atomic */
virtual void set_atomic() = 0;
/** Check if this object is atomic */
virtual bool is_atomic() = 0;
/** Pre-fetch data when reading */
virtual void set_prefetch_data() = 0;
/** Check if this object should prefetch */
virtual bool is_prefetch_data() = 0;
/** Mark data as compressed */
virtual void set_compressed() = 0;
/** Check if this object is compressed */
virtual bool is_compressed() = 0;
/** Invalidate cached info about this object, except atomic, prefetch, and
* compressed */
virtual void invalidate() = 0;
/** Check to see if this object has an empty key. This means it's uninitialized */
virtual bool empty() const = 0;
/** Get the name of this object */
virtual const std::string &get_name() const = 0;
/** Get the object state for this object. Will be removed in the future */
virtual int get_obj_state(const DoutPrefixProvider* dpp, RGWObjState **state, optional_yield y, bool follow_olh = true) = 0;
/** Set the object state for this object */
virtual void set_obj_state(RGWObjState& _state) = 0;
/** Set attributes for this object from the backing store. Attrs can be set or
* deleted. @note the attribute APIs may be revisited in the future. */
virtual int set_obj_attrs(const DoutPrefixProvider* dpp, Attrs* setattrs, Attrs* delattrs, optional_yield y) = 0;
/** Get attributes for this object */
virtual int get_obj_attrs(optional_yield y, const DoutPrefixProvider* dpp, rgw_obj* target_obj = NULL) = 0;
/** Modify attributes for this object. */
virtual int modify_obj_attrs(const char* attr_name, bufferlist& attr_val, optional_yield y, const DoutPrefixProvider* dpp) = 0;
/** Delete attributes for this object */
virtual int delete_obj_attrs(const DoutPrefixProvider* dpp, const char* attr_name, optional_yield y) = 0;
/** Check to see if this object has expired */
virtual bool is_expired() = 0;
/** Create a randomized instance ID for this object */
virtual void gen_rand_obj_instance_name() = 0;
/** Get a multipart serializer for this object */
virtual std::unique_ptr<MPSerializer> get_serializer(const DoutPrefixProvider *dpp,
const std::string& lock_name) = 0;
/** Move the data of an object to new placement storage */
virtual int transition(Bucket* bucket,
const rgw_placement_rule& placement_rule,
const real_time& mtime,
uint64_t olh_epoch,
const DoutPrefixProvider* dpp,
optional_yield y) = 0;
/** Move an object to the cloud */
virtual int transition_to_cloud(Bucket* bucket,
rgw::sal::PlacementTier* tier,
rgw_bucket_dir_entry& o,
std::set<std::string>& cloud_targets,
CephContext* cct,
bool update_object,
const DoutPrefixProvider* dpp,
optional_yield y) = 0;
/** Check to see if two placement rules match */
virtual bool placement_rules_match(rgw_placement_rule& r1, rgw_placement_rule& r2) = 0;
/** Dump driver-specific object layout info in JSON */
virtual int dump_obj_layout(const DoutPrefixProvider *dpp, optional_yield y, Formatter* f) = 0;
/** Get the cached attributes for this object */
virtual Attrs& get_attrs(void) = 0;
/** Get the (const) cached attributes for this object */
virtual const Attrs& get_attrs(void) const = 0;
/** Set the cached attributes for this object */
virtual int set_attrs(Attrs a) = 0;
/** Check to see if attributes are cached on this object */
virtual bool has_attrs(void) = 0;
/** Get the cached modification time for this object */
virtual ceph::real_time get_mtime(void) const = 0;
/** Get the cached size for this object */
virtual uint64_t get_obj_size(void) const = 0;
/** Get the bucket containing this object */
virtual Bucket* get_bucket(void) const = 0;
/** Set the bucket containing this object */
virtual void set_bucket(Bucket* b) = 0;
/** Get the sharding hash representation of this object */
virtual std::string get_hash_source(void) = 0;
/** Set the sharding hash representation of this object */
virtual void set_hash_source(std::string s) = 0;
/** Build an Object Identifier string for this object */
virtual std::string get_oid(void) const = 0;
/** True if this object is a delete marker (newest version is deleted) */
virtual bool get_delete_marker(void) = 0;
/** True if this object is stored in the extra data pool */
virtual bool get_in_extra_data(void) = 0;
/** Set the in_extra_data field */
virtual void set_in_extra_data(bool i) = 0;
/** Helper to sanitize object size, offset, and end values */
int range_to_ofs(uint64_t obj_size, int64_t &ofs, int64_t &end);
/** Set the cached size of this object */
virtual void set_obj_size(uint64_t s) = 0;
/** Set the cached name of this object */
virtual void set_name(const std::string& n) = 0;
/** Set the cached key of this object */
virtual void set_key(const rgw_obj_key& k) = 0;
/** Get an rgw_obj representing this object */
virtual rgw_obj get_obj(void) const = 0;
/** Restore the previous swift version of this object */
virtual int swift_versioning_restore(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,
optional_yield y) = 0;
/** Get a new ReadOp for this object */
virtual std::unique_ptr<ReadOp> get_read_op() = 0;
/** Get a new DeleteOp for this object */
virtual std::unique_ptr<DeleteOp> get_delete_op() = 0;
/// Return stored torrent info or -ENOENT if there isn't any.
virtual int get_torrent_info(const DoutPrefixProvider* dpp,
optional_yield y, bufferlist& bl) = 0;
/** Get the OMAP values matching the given set of keys */
virtual int omap_get_vals_by_keys(const DoutPrefixProvider *dpp, const std::string& oid,
const std::set<std::string>& keys,
Attrs* vals) = 0;
/** Get a single OMAP value matching the given key */
virtual int omap_set_val_by_key(const DoutPrefixProvider *dpp, const std::string& key, bufferlist& val,
bool must_exist, optional_yield y) = 0;
/** Change the ownership of this object */
virtual int chown(User& new_user, const DoutPrefixProvider* dpp, optional_yield y) = 0;
/** Check to see if the given object pointer is uninitialized */
static bool empty(const Object* o) { return (!o || o->empty()); }
/** Check to see if the given object unique pointer is uninitialized */
static bool empty(const std::unique_ptr<Object>& o) { return (!o || o->empty()); }
/** Get a unique copy of this object */
virtual std::unique_ptr<Object> clone() = 0;
/* dang - This is temporary, until the API is completed */
/** Get the key for this object */
virtual rgw_obj_key& get_key() = 0;
/** Set the instance for this object */
virtual void set_instance(const std::string &i) = 0;
/** Get the instance for this object */
virtual const std::string &get_instance() const = 0;
/** Check to see if this object has an instance set */
virtual bool have_instance(void) = 0;
/** Clear the instance on this object */
virtual void clear_instance() = 0;
/** Print the User to @a out */
virtual void print(std::ostream& out) const = 0;
friend inline std::ostream& operator<<(std::ostream& out, const Object& o) {
o.print(out);
return out;
}
friend inline std::ostream& operator<<(std::ostream& out, const Object* o) {
if (!o)
out << "<NULL>";
else
o->print(out);
return out;
}
friend inline std::ostream& operator<<(std::ostream& out, const std::unique_ptr<Object>& p) {
out << p.get();
return out;
}
};
/**
* @brief Abstraction of a single part of a multipart upload
*/
class MultipartPart {
public:
MultipartPart() = default;
virtual ~MultipartPart() = default;
/** Get the part number of this part */
virtual uint32_t get_num() = 0;
/** Get the size of this part */
virtual uint64_t get_size() = 0;
/** Get the etag of this part */
virtual const std::string& get_etag() = 0;
/** Get the modification time of this part */
virtual ceph::real_time& get_mtime() = 0;
};
/**
* @brief Abstraction of a multipart upload
*
* This represents a multipart upload. For large objects, it's inefficient to do a
* single, long-lived upload of the object. Instead, protocols such as S3 allow the
* client to start a multipart upload, and then upload object in smaller parts in
* parallel. A MultipartUpload consists of a target bucket, a unique identifier, and a
* set of upload parts.
*/
class MultipartUpload {
public:
MultipartUpload() = default;
virtual ~MultipartUpload() = default;
/** Get the name of the object representing this upload in the backing store */
virtual const std::string& get_meta() const = 0;
/** Get the name of the target object for this upload */
virtual const std::string& get_key() const = 0;
/** Get the unique ID of this upload */
virtual const std::string& get_upload_id() const = 0;
/** Get the owner of this upload */
virtual const ACLOwner& get_owner() const = 0;
/** Get the modification time of this upload */
virtual ceph::real_time& get_mtime() = 0;
/** Get all the cached parts that make up this upload */
virtual std::map<uint32_t, std::unique_ptr<MultipartPart>>& get_parts() = 0;
/** Get the trace context of this upload */
virtual const jspan_context& get_trace() = 0;
/** Get the Object that represents this upload */
virtual std::unique_ptr<rgw::sal::Object> get_meta_obj() = 0;
/** Initialize this upload */
virtual int init(const DoutPrefixProvider* dpp, optional_yield y, ACLOwner& owner, rgw_placement_rule& dest_placement, rgw::sal::Attrs& attrs) = 0;
/** List all the parts of this upload, filling the parts cache */
virtual int list_parts(const DoutPrefixProvider* dpp, CephContext* cct,
int num_parts, int marker,
int* next_marker, bool* truncated, optional_yield y,
bool assume_unsorted = false) = 0;
/** Abort this upload */
virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct, optional_yield y) = 0;
/** Complete this upload, making it available as a normal object */
virtual int complete(const DoutPrefixProvider* dpp,
optional_yield y, CephContext* cct,
std::map<int, std::string>& part_etags,
std::list<rgw_obj_index_key>& remove_objs,
uint64_t& accounted_size, bool& compressed,
RGWCompressionInfo& cs_info, off_t& ofs,
std::string& tag, ACLOwner& owner,
uint64_t olh_epoch,
rgw::sal::Object* target_obj) = 0;
/** Get placement and/or attribute info for this upload */
virtual int get_info(const DoutPrefixProvider *dpp, optional_yield y, rgw_placement_rule** rule, rgw::sal::Attrs* attrs = nullptr) = 0;
/** Get a Writer to write to a part of this upload */
virtual std::unique_ptr<Writer> get_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num,
const std::string& part_num_str) = 0;
/** Print the Upload to @a out */
virtual void print(std::ostream& out) const = 0;
friend inline std::ostream& operator<<(std::ostream& out, const MultipartUpload& u) {
u.print(out);
return out;
}
friend inline std::ostream& operator<<(std::ostream& out, const MultipartUpload* u) {
if (!u)
out << "<NULL>";
else
u->print(out);
return out;
}
friend inline std::ostream& operator<<(std::ostream& out, const
std::unique_ptr<MultipartUpload>& p) {
out << p.get();
return out;
}
};
/**
* @brief Interface of a lock/serialization
*/
class Serializer {
public:
Serializer() = default;
virtual ~Serializer() = default;
/** Try to take the lock for the given amount of time. */
virtual int try_lock(const DoutPrefixProvider *dpp, utime_t dur, optional_yield y) = 0;
/** Unlock the lock */
virtual int unlock() = 0;
/** Print the Serializer to @a out */
virtual void print(std::ostream& out) const = 0;
friend inline std::ostream& operator<<(std::ostream& out, const Serializer& s) {
s.print(out);
return out;
}
friend inline std::ostream& operator<<(std::ostream& out, const Serializer* s) {
if (!s)
out << "<NULL>";
else
s->print(out);
return out;
}
};
/** @brief Abstraction of a serializer for multipart uploads
*/
class MPSerializer : public Serializer {
public:
MPSerializer() = default;
virtual ~MPSerializer() = default;
virtual void clear_locked() = 0;
/** Check to see if locked */
virtual bool is_locked() = 0;
};
/** @brief Abstraction of a serializer for Lifecycle
*/
class LCSerializer : public Serializer {
public:
LCSerializer() {}
virtual ~LCSerializer() = default;
};
/**
* @brief Abstraction for lifecycle processing
*
* Lifecycle processing loops over the objects in a bucket, applying per-bucket policy
* to each object. Examples of policy can be deleting after a certain amount of time,
* deleting extra versions, changing the storage class, and so on.
*/
class Lifecycle {
public:
/** Head of a lifecycle run. Used for tracking parallel lifecycle runs. */
struct LCHead {
LCHead() = default;
virtual ~LCHead() = default;
virtual time_t& get_start_date() = 0;
virtual void set_start_date(time_t) = 0;
virtual std::string& get_marker() = 0;
virtual void set_marker(const std::string&) = 0;
virtual time_t& get_shard_rollover_date() = 0;
virtual void set_shard_rollover_date(time_t) = 0;
};
/** Single entry in a lifecycle run. Multiple entries can exist processing different
* buckets. */
struct LCEntry {
LCEntry() = default;
virtual ~LCEntry() = default;
virtual std::string& get_bucket() = 0;
virtual void set_bucket(const std::string&) = 0;
virtual std::string& get_oid() = 0;
virtual void set_oid(const std::string&) = 0;
virtual uint64_t get_start_time() = 0;
virtual void set_start_time(uint64_t) = 0;
virtual uint32_t get_status() = 0;
virtual void set_status(uint32_t) = 0;
/** Print the entry to @a out */
virtual void print(std::ostream& out) const = 0;
friend inline std::ostream& operator<<(std::ostream& out, const LCEntry& e) {
e.print(out);
return out;
}
friend inline std::ostream& operator<<(std::ostream& out, const LCEntry* e) {
if (!e)
out << "<NULL>";
else
e->print(out);
return out;
}
friend inline std::ostream& operator<<(std::ostream& out, const std::unique_ptr<LCEntry>& p) {
out << p.get();
return out;
}
};
Lifecycle() = default;
virtual ~Lifecycle() = default;
/** Get an empty entry */
virtual std::unique_ptr<LCEntry> get_entry() = 0;
/** Get an entry matching the given marker */
virtual int get_entry(const std::string& oid, const std::string& marker, std::unique_ptr<LCEntry>* entry) = 0;
/** Get the entry following the given marker */
virtual int get_next_entry(const std::string& oid, const std::string& marker, std::unique_ptr<LCEntry>* entry) = 0;
/** Store a modified entry in then backing store */
virtual int set_entry(const std::string& oid, LCEntry& entry) = 0;
/** List all known entries */
virtual int list_entries(const std::string& oid, const std::string& marker,
uint32_t max_entries,
std::vector<std::unique_ptr<LCEntry>>& entries) = 0;
/** Remove an entry from the backing store */
virtual int rm_entry(const std::string& oid, LCEntry& entry) = 0;
/** Get a head */
virtual int get_head(const std::string& oid, std::unique_ptr<LCHead>* head) = 0;
/** Store a modified head to the backing store */
virtual int put_head(const std::string& oid, LCHead& head) = 0;
/** Get a serializer for lifecycle */
virtual std::unique_ptr<LCSerializer> get_serializer(const std::string& lock_name,
const std::string& oid,
const std::string& cookie) = 0;
};
/**
* @brief Abstraction for a Notification event
*
* RGW can generate notifications for various events, such as object creation or
* deletion.
*/
class Notification {
protected:
public:
Notification() {}
virtual ~Notification() = default;
/** Indicate the start of the event associated with this notification */
virtual int publish_reserve(const DoutPrefixProvider *dpp, RGWObjTags* obj_tags = nullptr) = 0;
/** Indicate the successful completion of the event associated with this notification */
virtual int publish_commit(const DoutPrefixProvider* dpp, uint64_t size,
const ceph::real_time& mtime, const std::string& etag, const std::string& version) = 0;
};
/**
* @brief Abstraction for an asynchronous writer
*
* Writing is done through a set of filters. This allows chaining filters to do things
* like compression and encryption on async writes. This is the base abstraction for
* those filters.
*/
class Writer : public ObjectProcessor {
public:
Writer() {}
virtual ~Writer() = default;
/** prepare to start processing object data */
virtual int prepare(optional_yield y) = 0;
/**
* Process a buffer. Called multiple times to write different buffers.
* data.length() == 0 indicates the last call and may be used to flush
* the data buffers.
*/
virtual int process(bufferlist&& data, uint64_t offset) = 0;
/** complete the operation and make its result visible to clients */
virtual int complete(size_t accounted_size, const std::string& etag,
ceph::real_time *mtime, ceph::real_time set_mtime,
std::map<std::string, bufferlist>& attrs,
ceph::real_time delete_at,
const char *if_match, const char *if_nomatch,
const std::string *user_data,
rgw_zone_set *zones_trace, bool *canceled,
optional_yield y) = 0;
};
/**
* @brief Abstraction of a placement tier
*
* This abstraction allows access to information about placement tiers,
* including storage class.
*/
class PlacementTier {
public:
virtual ~PlacementTier() = default;
/** Get the type of this tier */
virtual const std::string& get_tier_type() = 0;
/** Get the storage class of this tier */
virtual const std::string& get_storage_class() = 0;
/** Should we retain the head object when transitioning */
virtual bool retain_head_object() = 0;
/** Get the placement rule associated with this tier */
};
/**
* @brief Abstraction of a zone group
*
* This class allows access to information about a zonegroup. It may be the
* group containing the current zone, or another group.
*/
class ZoneGroup {
public:
virtual ~ZoneGroup() = default;
/** Get the ID of this zonegroup */
virtual const std::string& get_id() const = 0;
/** Get the name of this zonegroup */
virtual const std::string& get_name() const = 0;
/** Determine if two zonegroups are the same */
virtual int equals(const std::string& other_zonegroup) const = 0;
/** Get the endpoint from zonegroup, or from master zone if not set */
virtual const std::string& get_endpoint() const = 0;
/** Check if a placement target (by name) exists in this zonegroup */
virtual bool placement_target_exists(std::string& target) const = 0;
/** Check if this is the master zonegroup */
virtual bool is_master_zonegroup() const = 0;
/** Get the API name of this zonegroup */
virtual const std::string& get_api_name() const = 0;
/** Get the list of placement target names for this zone */
virtual int get_placement_target_names(std::set<std::string>& names) const = 0;
/** Get the name of the default placement target for this zone */
virtual const std::string& get_default_placement_name() const = 0;
/** Get the list of hostnames from this zone */
virtual int get_hostnames(std::list<std::string>& names) const = 0;
/** Get the list of hostnames that host s3 websites from this zone */
virtual int get_s3website_hostnames(std::list<std::string>& names) const = 0;
/** Get the number of zones in this zonegroup */
virtual int get_zone_count() const = 0;
/** Get the placement tier associated with the rule */
virtual int get_placement_tier(const rgw_placement_rule& rule, std::unique_ptr<PlacementTier>* tier) = 0;
/** Get a zone by ID */
virtual int get_zone_by_id(const std::string& id, std::unique_ptr<Zone>* zone) = 0;
/** Get a zone by Name */
virtual int get_zone_by_name(const std::string& name, std::unique_ptr<Zone>* zone) = 0;
/** List zones in zone group by ID */
virtual int list_zones(std::list<std::string>& zone_ids) = 0;
/** Clone a copy of this zonegroup. */
virtual std::unique_ptr<ZoneGroup> clone() = 0;
};
/**
* @brief Abstraction of a Zone
*
* This abstraction allows access to information about zones. This can be the zone
* containing the RGW, or another zone.
*/
class Zone {
public:
virtual ~Zone() = default;
/** Clone a copy of this zone. */
virtual std::unique_ptr<Zone> clone() = 0;
/** Get info about the zonegroup containing this zone */
virtual ZoneGroup& get_zonegroup() = 0;
/** Get the ID of this zone */
virtual const std::string& get_id() = 0;
/** Get the name of this zone */
virtual const std::string& get_name() const = 0;
/** True if this zone is writable */
virtual bool is_writeable() = 0;
/** Get the URL for the endpoint for redirecting to this zone */
virtual bool get_redirect_endpoint(std::string* endpoint) = 0;
/** Check to see if the given API is supported in this zone */
virtual bool has_zonegroup_api(const std::string& api) const = 0;
/** Get the current period ID for this zone */
virtual const std::string& get_current_period_id() = 0;
/** Get thes system access key for this zone */
virtual const RGWAccessKey& get_system_key() = 0;
/** Get the name of the realm containing this zone */
virtual const std::string& get_realm_name() = 0;
/** Get the ID of the realm containing this zone */
virtual const std::string& get_realm_id() = 0;
/** Get the tier type for the zone */
virtual const std::string_view get_tier_type() = 0;
/** Get a handler for zone sync policy. */
virtual RGWBucketSyncPolicyHandlerRef get_sync_policy_handler() = 0;
};
/**
* @brief Abstraction of a manager for Lua scripts and packages
*
* RGW can load and process Lua scripts. This will handle loading/storing scripts; adding, deleting, and listing packages
*/
class LuaManager {
public:
virtual ~LuaManager() = default;
/** Get a script named with the given key from the backing store */
virtual int get_script(const DoutPrefixProvider* dpp, optional_yield y, const std::string& key, std::string& script) = 0;
/** Put a script named with the given key to the backing store */
virtual int put_script(const DoutPrefixProvider* dpp, optional_yield y, const std::string& key, const std::string& script) = 0;
/** Delete a script named with the given key from the backing store */
virtual int del_script(const DoutPrefixProvider* dpp, optional_yield y, const std::string& key) = 0;
/** Add a lua package */
virtual int add_package(const DoutPrefixProvider* dpp, optional_yield y, const std::string& package_name) = 0;
/** Remove a lua package */
virtual int remove_package(const DoutPrefixProvider* dpp, optional_yield y, const std::string& package_name) = 0;
/** List lua packages */
virtual int list_packages(const DoutPrefixProvider* dpp, optional_yield y, rgw::lua::packages_t& packages) = 0;
};
/** @} namespace rgw::sal in group RGWSAL */
} } // namespace rgw::sal
/**
* @brief A manager for Drivers
*
* This will manage the singleton instances of the various drivers. Drivers come in two
* varieties: Full and Raw. A full driver is suitable for use in a radosgw daemon. It
* has full access to the cluster, if any. A raw driver is a stripped down driver, used
* for admin commands.
*/
class DriverManager {
public:
struct Config {
/** Name of store to create */
std::string store_name;
/** Name of filter to create or "none" */
std::string filter_name;
};
DriverManager() {}
/** Get a full driver by service name */
static rgw::sal::Driver* get_storage(const DoutPrefixProvider* dpp,
CephContext* cct,
const Config& cfg,
bool use_gc_thread,
bool use_lc_thread,
bool quota_threads,
bool run_sync_thread,
bool run_reshard_thread,
bool run_notification_thread, optional_yield y,
bool use_cache = true,
bool use_gc = true) {
rgw::sal::Driver* driver = init_storage_provider(dpp, cct, cfg, use_gc_thread,
use_lc_thread,
quota_threads,
run_sync_thread,
run_reshard_thread,
run_notification_thread,
use_cache, use_gc, y);
return driver;
}
/** Get a stripped down driver by service name */
static rgw::sal::Driver* get_raw_storage(const DoutPrefixProvider* dpp,
CephContext* cct, const Config& cfg) {
rgw::sal::Driver* driver = init_raw_storage_provider(dpp, cct, cfg);
return driver;
}
/** Initialize a new full Driver */
static rgw::sal::Driver* init_storage_provider(const DoutPrefixProvider* dpp,
CephContext* cct,
const Config& cfg,
bool use_gc_thread,
bool use_lc_thread,
bool quota_threads,
bool run_sync_thread,
bool run_reshard_thread,
bool run_notification_thread,
bool use_metadata_cache,
bool use_gc, optional_yield y);
/** Initialize a new raw Driver */
static rgw::sal::Driver* init_raw_storage_provider(const DoutPrefixProvider* dpp,
CephContext* cct,
const Config& cfg);
/** Close a Driver when it's no longer needed */
static void close_storage(rgw::sal::Driver* driver);
/** Get the config for Drivers */
static Config get_config(bool admin, CephContext* cct);
/** Create a ConfigStore */
static auto create_config_store(const DoutPrefixProvider* dpp,
std::string_view type)
-> std::unique_ptr<rgw::sal::ConfigStore>;
};
/** @} */
| 70,616 | 42.059146 | 203 |
h
|
null |
ceph-main/src/rgw/rgw_sal_config.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2022 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#pragma once
#include <memory>
#include <optional>
#include <span>
#include <string>
#include "rgw_sal_fwd.h"
class DoutPrefixProvider;
class optional_yield;
struct RGWPeriod;
struct RGWPeriodConfig;
struct RGWRealm;
struct RGWZoneGroup;
struct RGWZoneParams;
namespace rgw::sal {
/// Results of a listing operation
template <typename T>
struct ListResult {
/// The subspan of the input entries that contain results
std::span<T> entries;
/// The next marker to resume listing, or empty
std::string next;
};
/// Storage abstraction for realm/zonegroup/zone configuration
class ConfigStore {
public:
virtual ~ConfigStore() {}
/// @group Realm
///@{
/// Set the cluster-wide default realm id
virtual int write_default_realm_id(const DoutPrefixProvider* dpp,
optional_yield y, bool exclusive,
std::string_view realm_id) = 0;
/// Read the cluster's default realm id
virtual int read_default_realm_id(const DoutPrefixProvider* dpp,
optional_yield y,
std::string& realm_id) = 0;
/// Delete the cluster's default realm id
virtual int delete_default_realm_id(const DoutPrefixProvider* dpp,
optional_yield y) = 0;
/// Create a realm
virtual int create_realm(const DoutPrefixProvider* dpp,
optional_yield y, bool exclusive,
const RGWRealm& info,
std::unique_ptr<RealmWriter>* writer) = 0;
/// Read a realm by id
virtual int read_realm_by_id(const DoutPrefixProvider* dpp,
optional_yield y,
std::string_view realm_id,
RGWRealm& info,
std::unique_ptr<RealmWriter>* writer) = 0;
/// Read a realm by name
virtual int read_realm_by_name(const DoutPrefixProvider* dpp,
optional_yield y,
std::string_view realm_name,
RGWRealm& info,
std::unique_ptr<RealmWriter>* writer) = 0;
/// Read the cluster's default realm
virtual int read_default_realm(const DoutPrefixProvider* dpp,
optional_yield y,
RGWRealm& info,
std::unique_ptr<RealmWriter>* writer) = 0;
/// Look up a realm id by its name
virtual int read_realm_id(const DoutPrefixProvider* dpp,
optional_yield y, std::string_view realm_name,
std::string& realm_id) = 0;
/// Notify the cluster of a new period, so radosgws can reload with the new
/// configuration
virtual int realm_notify_new_period(const DoutPrefixProvider* dpp,
optional_yield y,
const RGWPeriod& period) = 0;
/// List up to 'entries.size()' realm names starting from the given marker
virtual int list_realm_names(const DoutPrefixProvider* dpp,
optional_yield y, const std::string& marker,
std::span<std::string> entries,
ListResult<std::string>& result) = 0;
///@}
/// @group Period
///@{
/// Write a period and advance its latest epoch
virtual int create_period(const DoutPrefixProvider* dpp,
optional_yield y, bool exclusive,
const RGWPeriod& info) = 0;
/// Read a period by id and epoch. If no epoch is given, read the latest
virtual int read_period(const DoutPrefixProvider* dpp,
optional_yield y, std::string_view period_id,
std::optional<uint32_t> epoch, RGWPeriod& info) = 0;
/// Delete all period epochs with the given period id
virtual int delete_period(const DoutPrefixProvider* dpp,
optional_yield y,
std::string_view period_id) = 0;
/// List up to 'entries.size()' period ids starting from the given marker
virtual int list_period_ids(const DoutPrefixProvider* dpp,
optional_yield y, const std::string& marker,
std::span<std::string> entries,
ListResult<std::string>& result) = 0;
///@}
/// @group ZoneGroup
///@{
/// Set the cluster-wide default zonegroup id
virtual int write_default_zonegroup_id(const DoutPrefixProvider* dpp,
optional_yield y, bool exclusive,
std::string_view realm_id,
std::string_view zonegroup_id) = 0;
/// Read the cluster's default zonegroup id
virtual int read_default_zonegroup_id(const DoutPrefixProvider* dpp,
optional_yield y,
std::string_view realm_id,
std::string& zonegroup_id) = 0;
/// Delete the cluster's default zonegroup id
virtual int delete_default_zonegroup_id(const DoutPrefixProvider* dpp,
optional_yield y,
std::string_view realm_id) = 0;
/// Create a zonegroup
virtual int create_zonegroup(const DoutPrefixProvider* dpp,
optional_yield y, bool exclusive,
const RGWZoneGroup& info,
std::unique_ptr<ZoneGroupWriter>* writer) = 0;
/// Read a zonegroup by id
virtual int read_zonegroup_by_id(const DoutPrefixProvider* dpp,
optional_yield y,
std::string_view zonegroup_id,
RGWZoneGroup& info,
std::unique_ptr<ZoneGroupWriter>* writer) = 0;
/// Read a zonegroup by name
virtual int read_zonegroup_by_name(const DoutPrefixProvider* dpp,
optional_yield y,
std::string_view zonegroup_name,
RGWZoneGroup& info,
std::unique_ptr<ZoneGroupWriter>* writer) = 0;
/// Read the cluster's default zonegroup
virtual int read_default_zonegroup(const DoutPrefixProvider* dpp,
optional_yield y,
std::string_view realm_id,
RGWZoneGroup& info,
std::unique_ptr<ZoneGroupWriter>* writer) = 0;
/// List up to 'entries.size()' zonegroup names starting from the given marker
virtual int list_zonegroup_names(const DoutPrefixProvider* dpp,
optional_yield y, const std::string& marker,
std::span<std::string> entries,
ListResult<std::string>& result) = 0;
///@}
/// @group Zone
///@{
/// Set the realm-wide default zone id
virtual int write_default_zone_id(const DoutPrefixProvider* dpp,
optional_yield y, bool exclusive,
std::string_view realm_id,
std::string_view zone_id) = 0;
/// Read the realm's default zone id
virtual int read_default_zone_id(const DoutPrefixProvider* dpp,
optional_yield y,
std::string_view realm_id,
std::string& zone_id) = 0;
/// Delete the realm's default zone id
virtual int delete_default_zone_id(const DoutPrefixProvider* dpp,
optional_yield y,
std::string_view realm_id) = 0;
/// Create a zone
virtual int create_zone(const DoutPrefixProvider* dpp,
optional_yield y, bool exclusive,
const RGWZoneParams& info,
std::unique_ptr<ZoneWriter>* writer) = 0;
/// Read a zone by id
virtual int read_zone_by_id(const DoutPrefixProvider* dpp,
optional_yield y,
std::string_view zone_id,
RGWZoneParams& info,
std::unique_ptr<ZoneWriter>* writer) = 0;
/// Read a zone by id or name. If both are empty, try to load the
/// cluster's default zone
virtual int read_zone_by_name(const DoutPrefixProvider* dpp,
optional_yield y,
std::string_view zone_name,
RGWZoneParams& info,
std::unique_ptr<ZoneWriter>* writer) = 0;
/// Read the realm's default zone
virtual int read_default_zone(const DoutPrefixProvider* dpp,
optional_yield y,
std::string_view realm_id,
RGWZoneParams& info,
std::unique_ptr<ZoneWriter>* writer) = 0;
/// List up to 'entries.size()' zone names starting from the given marker
virtual int list_zone_names(const DoutPrefixProvider* dpp,
optional_yield y, const std::string& marker,
std::span<std::string> entries,
ListResult<std::string>& result) = 0;
///@}
/// @group PeriodConfig
///@{
/// Read period config object
virtual int read_period_config(const DoutPrefixProvider* dpp,
optional_yield y,
std::string_view realm_id,
RGWPeriodConfig& info) = 0;
/// Write period config object
virtual int write_period_config(const DoutPrefixProvider* dpp,
optional_yield y, bool exclusive,
std::string_view realm_id,
const RGWPeriodConfig& info) = 0;
///@}
}; // ConfigStore
/// A handle to manage the atomic updates of an existing realm object. This
/// is initialized on read, and any subsequent writes through this handle will
/// fail with -ECANCELED if another writer updates the object in the meantime.
class RealmWriter {
public:
virtual ~RealmWriter() {}
/// Overwrite an existing realm. Must not change id or name
virtual int write(const DoutPrefixProvider* dpp,
optional_yield y,
const RGWRealm& info) = 0;
/// Rename an existing realm. Must not change id
virtual int rename(const DoutPrefixProvider* dpp,
optional_yield y,
RGWRealm& info,
std::string_view new_name) = 0;
/// Delete an existing realm
virtual int remove(const DoutPrefixProvider* dpp,
optional_yield y) = 0;
};
/// A handle to manage the atomic updates of an existing zonegroup object. This
/// is initialized on read, and any subsequent writes through this handle will
/// fail with -ECANCELED if another writer updates the object in the meantime.
class ZoneGroupWriter {
public:
virtual ~ZoneGroupWriter() {}
/// Overwrite an existing zonegroup. Must not change id or name
virtual int write(const DoutPrefixProvider* dpp,
optional_yield y,
const RGWZoneGroup& info) = 0;
/// Rename an existing zonegroup. Must not change id
virtual int rename(const DoutPrefixProvider* dpp,
optional_yield y,
RGWZoneGroup& info,
std::string_view new_name) = 0;
/// Delete an existing zonegroup
virtual int remove(const DoutPrefixProvider* dpp,
optional_yield y) = 0;
};
/// A handle to manage the atomic updates of an existing zone object. This
/// is initialized on read, and any subsequent writes through this handle will
/// fail with -ECANCELED if another writer updates the object in the meantime.
class ZoneWriter {
public:
virtual ~ZoneWriter() {}
/// Overwrite an existing zone. Must not change id or name
virtual int write(const DoutPrefixProvider* dpp,
optional_yield y,
const RGWZoneParams& info) = 0;
/// Rename an existing zone. Must not change id
virtual int rename(const DoutPrefixProvider* dpp,
optional_yield y,
RGWZoneParams& info,
std::string_view new_name) = 0;
/// Delete an existing zone
virtual int remove(const DoutPrefixProvider* dpp,
optional_yield y) = 0;
};
} // namespace rgw::sal
| 13,345 | 43.192053 | 83 |
h
|
null |
ceph-main/src/rgw/rgw_sal_daos.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=2 sw=2 expandtab ft=cpp
/*
* Ceph - scalable distributed file system
*
* SAL implementation for the CORTX DAOS backend
*
* Copyright (C) 2022 Seagate Technology LLC and/or its Affiliates
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "rgw_sal_daos.h"
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <filesystem>
#include <system_error>
#include "common/Clock.h"
#include "common/errno.h"
#include "rgw_bucket.h"
#include "rgw_compression.h"
#include "rgw_sal.h"
#define dout_subsys ceph_subsys_rgw
using std::list;
using std::map;
using std::set;
using std::string;
using std::vector;
namespace fs = std::filesystem;
namespace rgw::sal {
using ::ceph::decode;
using ::ceph::encode;
int DaosUser::list_buckets(const DoutPrefixProvider* dpp, const string& marker,
const string& end_marker, uint64_t max,
bool need_stats, BucketList& buckets,
optional_yield y) {
ldpp_dout(dpp, 20) << "DEBUG: list_user_buckets: marker=" << marker
<< " end_marker=" << end_marker << " max=" << max << dendl;
int ret = 0;
bool is_truncated = false;
buckets.clear();
vector<struct ds3_bucket_info> bucket_infos(max);
daos_size_t bcount = bucket_infos.size();
vector<vector<uint8_t>> values(bcount, vector<uint8_t>(DS3_MAX_ENCODED_LEN));
for (daos_size_t i = 0; i < bcount; i++) {
bucket_infos[i].encoded = values[i].data();
bucket_infos[i].encoded_length = values[i].size();
}
char daos_marker[DS3_MAX_BUCKET_NAME];
std::strncpy(daos_marker, marker.c_str(), sizeof(daos_marker));
ret = ds3_bucket_list(&bcount, bucket_infos.data(), daos_marker,
&is_truncated, store->ds3, nullptr);
ldpp_dout(dpp, 20) << "DEBUG: ds3_bucket_list: bcount=" << bcount
<< " ret=" << ret << dendl;
if (ret != 0) {
ldpp_dout(dpp, 0) << "ERROR: ds3_bucket_list failed!" << ret << dendl;
return ret;
}
bucket_infos.resize(bcount);
values.resize(bcount);
for (const auto& bi : bucket_infos) {
DaosBucketInfo dbinfo;
bufferlist bl;
bl.append(reinterpret_cast<char*>(bi.encoded), bi.encoded_length);
auto iter = bl.cbegin();
dbinfo.decode(iter);
buckets.add(std::make_unique<DaosBucket>(this->store, dbinfo.info, this));
}
buckets.set_truncated(is_truncated);
return 0;
}
int DaosUser::create_bucket(
const DoutPrefixProvider* dpp, const rgw_bucket& b,
const std::string& zonegroup_id, rgw_placement_rule& placement_rule,
std::string& swift_ver_location, const RGWQuotaInfo* pquota_info,
const RGWAccessControlPolicy& policy, Attrs& attrs, RGWBucketInfo& info,
obj_version& ep_objv, bool exclusive, bool obj_lock_enabled, bool* existed,
req_info& req_info, std::unique_ptr<Bucket>* bucket_out, optional_yield y) {
ldpp_dout(dpp, 20) << "DEBUG: create_bucket:" << b.name << dendl;
int ret;
std::unique_ptr<Bucket> bucket;
// Look up the bucket. Create it if it doesn't exist.
ret = this->store->get_bucket(dpp, this, b, &bucket, y);
if (ret != 0 && ret != -ENOENT) {
return ret;
}
if (ret != -ENOENT) {
*existed = true;
if (swift_ver_location.empty()) {
swift_ver_location = bucket->get_info().swift_ver_location;
}
placement_rule.inherit_from(bucket->get_info().placement_rule);
// TODO: ACL policy
// // don't allow changes to the acl policy
// RGWAccessControlPolicy old_policy(ctx());
// int rc = rgw_op_get_bucket_policy_from_attr(
// dpp, this, u, bucket->get_attrs(), &old_policy, y);
// if (rc >= 0 && old_policy != policy) {
// bucket_out->swap(bucket);
// return -EEXIST;
//}
} else {
placement_rule.name = "default";
placement_rule.storage_class = "STANDARD";
bucket = std::make_unique<DaosBucket>(store, b, this);
bucket->set_attrs(attrs);
*existed = false;
}
// TODO: how to handle zone and multi-site.
if (!*existed) {
info.placement_rule = placement_rule;
info.bucket = b;
info.owner = this->get_info().user_id;
info.zonegroup = zonegroup_id;
info.creation_time = ceph::real_clock::now();
if (obj_lock_enabled)
info.flags = BUCKET_VERSIONED | BUCKET_OBJ_LOCK_ENABLED;
bucket->set_version(ep_objv);
bucket->get_info() = info;
// Create a new bucket:
DaosBucket* daos_bucket = static_cast<DaosBucket*>(bucket.get());
bufferlist bl;
std::unique_ptr<struct ds3_bucket_info> bucket_info =
daos_bucket->get_encoded_info(bl, ceph::real_time());
ret = ds3_bucket_create(bucket->get_name().c_str(), bucket_info.get(),
nullptr, store->ds3, nullptr);
if (ret != 0) {
ldpp_dout(dpp, 0) << "ERROR: ds3_bucket_create failed! ret=" << ret
<< dendl;
return ret;
}
} else {
bucket->set_version(ep_objv);
bucket->get_info() = info;
}
bucket_out->swap(bucket);
return ret;
}
int DaosUser::read_attrs(const DoutPrefixProvider* dpp, optional_yield y) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosUser::read_stats(const DoutPrefixProvider* dpp, optional_yield y,
RGWStorageStats* stats,
ceph::real_time* last_stats_sync,
ceph::real_time* last_stats_update) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
/* stats - Not for first pass */
int DaosUser::read_stats_async(const DoutPrefixProvider* dpp,
RGWGetUserStats_CB* cb) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosUser::complete_flush_stats(const DoutPrefixProvider* dpp,
optional_yield y) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosUser::read_usage(const DoutPrefixProvider* dpp, uint64_t start_epoch,
uint64_t end_epoch, uint32_t max_entries,
bool* is_truncated, RGWUsageIter& usage_iter,
map<rgw_user_bucket, rgw_usage_log_entry>& usage) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosUser::trim_usage(const DoutPrefixProvider* dpp, uint64_t start_epoch,
uint64_t end_epoch) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosUser::load_user(const DoutPrefixProvider* dpp, optional_yield y) {
const string name = info.user_id.to_str();
ldpp_dout(dpp, 20) << "DEBUG: load_user, name=" << name << dendl;
DaosUserInfo duinfo;
int ret = read_user(dpp, name, &duinfo);
if (ret != 0) {
ldpp_dout(dpp, 0) << "ERROR: load_user failed, name=" << name << dendl;
return ret;
}
info = duinfo.info;
attrs = duinfo.attrs;
objv_tracker.read_version = duinfo.user_version;
return 0;
}
int DaosUser::merge_and_store_attrs(const DoutPrefixProvider* dpp,
Attrs& new_attrs, optional_yield y) {
ldpp_dout(dpp, 20) << "DEBUG: merge_and_store_attrs, new_attrs=" << new_attrs
<< dendl;
for (auto& it : new_attrs) {
attrs[it.first] = it.second;
}
return store_user(dpp, y, false);
}
int DaosUser::store_user(const DoutPrefixProvider* dpp, optional_yield y,
bool exclusive, RGWUserInfo* old_info) {
const string name = info.user_id.to_str();
ldpp_dout(dpp, 10) << "DEBUG: Store_user(): User name=" << name << dendl;
// Read user
int ret = 0;
struct DaosUserInfo duinfo;
ret = read_user(dpp, name, &duinfo);
obj_version obj_ver = duinfo.user_version;
std::unique_ptr<struct ds3_user_info> old_user_info;
std::vector<const char*> old_access_ids;
// Check if the user already exists
if (ret == 0 && obj_ver.ver) {
// already exists.
if (old_info) {
*old_info = duinfo.info;
}
if (objv_tracker.read_version.ver != obj_ver.ver) {
// Object version mismatch.. return ECANCELED
ret = -ECANCELED;
ldpp_dout(dpp, 0) << "User Read version mismatch read_version="
<< objv_tracker.read_version.ver
<< " obj_ver=" << obj_ver.ver << dendl;
return ret;
}
if (exclusive) {
// return
return ret;
}
obj_ver.ver++;
for (auto const& [id, key] : duinfo.info.access_keys) {
old_access_ids.push_back(id.c_str());
}
old_user_info.reset(
new ds3_user_info{.name = duinfo.info.user_id.to_str().c_str(),
.email = duinfo.info.user_email.c_str(),
.access_ids = old_access_ids.data(),
.access_ids_nr = old_access_ids.size()});
} else {
obj_ver.ver = 1;
obj_ver.tag = "UserTAG";
}
bufferlist bl;
std::unique_ptr<struct ds3_user_info> user_info =
get_encoded_info(bl, obj_ver);
ret = ds3_user_set(name.c_str(), user_info.get(), old_user_info.get(),
store->ds3, nullptr);
if (ret != 0) {
ldpp_dout(dpp, 0) << "Error: ds3_user_set failed, name=" << name
<< " ret=" << ret << dendl;
}
return ret;
}
int DaosUser::read_user(const DoutPrefixProvider* dpp, std::string name,
DaosUserInfo* duinfo) {
// Initialize ds3_user_info
bufferlist bl;
uint64_t size = DS3_MAX_ENCODED_LEN;
struct ds3_user_info user_info = {.encoded = bl.append_hole(size).c_str(),
.encoded_length = size};
int ret = ds3_user_get(name.c_str(), &user_info, store->ds3, nullptr);
if (ret != 0) {
ldpp_dout(dpp, 0) << "Error: ds3_user_get failed, name=" << name
<< " ret=" << ret << dendl;
return ret;
}
// Decode
bufferlist& blr = bl;
auto iter = blr.cbegin();
duinfo->decode(iter);
return ret;
}
std::unique_ptr<struct ds3_user_info> DaosUser::get_encoded_info(
bufferlist& bl, obj_version& obj_ver) {
// Encode user data
struct DaosUserInfo duinfo;
duinfo.info = info;
duinfo.attrs = attrs;
duinfo.user_version = obj_ver;
duinfo.encode(bl);
// Initialize ds3_user_info
access_ids.clear();
for (auto const& [id, key] : info.access_keys) {
access_ids.push_back(id.c_str());
}
return std::unique_ptr<struct ds3_user_info>(
new ds3_user_info{.name = info.user_id.to_str().c_str(),
.email = info.user_email.c_str(),
.access_ids = access_ids.data(),
.access_ids_nr = access_ids.size(),
.encoded = bl.c_str(),
.encoded_length = bl.length()});
}
int DaosUser::remove_user(const DoutPrefixProvider* dpp, optional_yield y) {
const string name = info.user_id.to_str();
// TODO: the expectation is that the object version needs to be passed in as a
// method arg see int DB::remove_user(const DoutPrefixProvider *dpp,
// RGWUserInfo& uinfo, RGWObjVersionTracker *pobjv)
obj_version obj_ver;
bufferlist bl;
std::unique_ptr<struct ds3_user_info> user_info =
get_encoded_info(bl, obj_ver);
// Remove user
int ret = ds3_user_remove(name.c_str(), user_info.get(), store->ds3, nullptr);
if (ret != 0) {
ldpp_dout(dpp, 0) << "Error: ds3_user_set failed, name=" << name
<< " ret=" << ret << dendl;
}
return ret;
}
DaosBucket::~DaosBucket() { close(nullptr); }
int DaosBucket::open(const DoutPrefixProvider* dpp) {
ldpp_dout(dpp, 20) << "DEBUG: open, name=" << info.bucket.name.c_str()
<< dendl;
// Idempotent
if (is_open()) {
return 0;
}
int ret = ds3_bucket_open(get_name().c_str(), &ds3b, store->ds3, nullptr);
ldpp_dout(dpp, 20) << "DEBUG: ds3_bucket_open, name=" << get_name()
<< ", ret=" << ret << dendl;
return ret;
}
int DaosBucket::close(const DoutPrefixProvider* dpp) {
ldpp_dout(dpp, 20) << "DEBUG: close" << dendl;
// Idempotent
if (!is_open()) {
return 0;
}
int ret = ds3_bucket_close(ds3b, nullptr);
ds3b = nullptr;
ldpp_dout(dpp, 20) << "DEBUG: ds3_bucket_close ret=" << ret << dendl;
return ret;
}
std::unique_ptr<struct ds3_bucket_info> DaosBucket::get_encoded_info(
bufferlist& bl, ceph::real_time _mtime) {
DaosBucketInfo dbinfo;
dbinfo.info = info;
dbinfo.bucket_attrs = attrs;
dbinfo.mtime = _mtime;
dbinfo.bucket_version = bucket_version;
dbinfo.encode(bl);
auto bucket_info = std::make_unique<struct ds3_bucket_info>();
bucket_info->encoded = bl.c_str();
bucket_info->encoded_length = bl.length();
std::strncpy(bucket_info->name, get_name().c_str(), sizeof(bucket_info->name));
return bucket_info;
}
int DaosBucket::remove_bucket(const DoutPrefixProvider* dpp,
bool delete_children, bool forward_to_master,
req_info* req_info, optional_yield y) {
ldpp_dout(dpp, 20) << "DEBUG: remove_bucket, delete_children="
<< delete_children
<< " forward_to_master=" << forward_to_master << dendl;
return ds3_bucket_destroy(get_name().c_str(), delete_children, store->ds3,
nullptr);
}
int DaosBucket::remove_bucket_bypass_gc(int concurrent_max,
bool keep_index_consistent,
optional_yield y,
const DoutPrefixProvider* dpp) {
ldpp_dout(dpp, 20) << "DEBUG: remove_bucket_bypass_gc, concurrent_max="
<< concurrent_max
<< " keep_index_consistent=" << keep_index_consistent
<< dendl;
return ds3_bucket_destroy(get_name().c_str(), true, store->ds3, nullptr);
}
int DaosBucket::put_info(const DoutPrefixProvider* dpp, bool exclusive,
ceph::real_time _mtime) {
ldpp_dout(dpp, 20) << "DEBUG: put_info(): bucket name=" << get_name()
<< dendl;
int ret = open(dpp);
if (ret != 0) {
return ret;
}
bufferlist bl;
std::unique_ptr<struct ds3_bucket_info> bucket_info =
get_encoded_info(bl, ceph::real_time());
ret = ds3_bucket_set_info(bucket_info.get(), ds3b, nullptr);
if (ret != 0) {
ldpp_dout(dpp, 0) << "ERROR: ds3_bucket_set_info failed: " << ret << dendl;
}
return ret;
}
int DaosBucket::load_bucket(const DoutPrefixProvider* dpp, optional_yield y,
bool get_stats) {
ldpp_dout(dpp, 20) << "DEBUG: load_bucket(): bucket name=" << get_name()
<< dendl;
int ret = open(dpp);
if (ret != 0) {
return ret;
}
bufferlist bl;
DaosBucketInfo dbinfo;
uint64_t size = DS3_MAX_ENCODED_LEN;
struct ds3_bucket_info bucket_info = {.encoded = bl.append_hole(size).c_str(),
.encoded_length = size};
ret = ds3_bucket_get_info(&bucket_info, ds3b, nullptr);
if (ret != 0) {
ldpp_dout(dpp, 0) << "ERROR: ds3_bucket_get_info failed: " << ret << dendl;
return ret;
}
auto iter = bl.cbegin();
dbinfo.decode(iter);
info = dbinfo.info;
rgw_placement_rule placement_rule;
placement_rule.name = "default";
placement_rule.storage_class = "STANDARD";
info.placement_rule = placement_rule;
attrs = dbinfo.bucket_attrs;
mtime = dbinfo.mtime;
bucket_version = dbinfo.bucket_version;
return ret;
}
/* stats - Not for first pass */
int DaosBucket::read_stats(const DoutPrefixProvider* dpp,
const bucket_index_layout_generation& idx_layout,
int shard_id, std::string* bucket_ver,
std::string* master_ver,
std::map<RGWObjCategory, RGWStorageStats>& stats,
std::string* max_marker, bool* syncstopped) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosBucket::read_stats_async(
const DoutPrefixProvider* dpp,
const bucket_index_layout_generation& idx_layout, int shard_id,
RGWGetBucketStats_CB* ctx) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosBucket::sync_user_stats(const DoutPrefixProvider* dpp,
optional_yield y) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosBucket::update_container_stats(const DoutPrefixProvider* dpp) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosBucket::check_bucket_shards(const DoutPrefixProvider* dpp) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosBucket::chown(const DoutPrefixProvider* dpp, User& new_user,
optional_yield y) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
/* Make sure to call load_bucket() if you need it first */
bool DaosBucket::is_owner(User* user) {
return (info.owner.compare(user->get_id()) == 0);
}
int DaosBucket::check_empty(const DoutPrefixProvider* dpp, optional_yield y) {
/* XXX: Check if bucket contains any objects */
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosBucket::check_quota(const DoutPrefixProvider* dpp, RGWQuota& quota,
uint64_t obj_size, optional_yield y,
bool check_size_only) {
/* Not Handled in the first pass as stats are also needed */
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosBucket::merge_and_store_attrs(const DoutPrefixProvider* dpp,
Attrs& new_attrs, optional_yield y) {
ldpp_dout(dpp, 20) << "DEBUG: merge_and_store_attrs, new_attrs=" << new_attrs
<< dendl;
for (auto& it : new_attrs) {
attrs[it.first] = it.second;
}
return put_info(dpp, y, ceph::real_time());
}
int DaosBucket::try_refresh_info(const DoutPrefixProvider* dpp,
ceph::real_time* pmtime) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
/* XXX: usage and stats not supported in the first pass */
int DaosBucket::read_usage(const DoutPrefixProvider* dpp, uint64_t start_epoch,
uint64_t end_epoch, uint32_t max_entries,
bool* is_truncated, RGWUsageIter& usage_iter,
map<rgw_user_bucket, rgw_usage_log_entry>& usage) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosBucket::trim_usage(const DoutPrefixProvider* dpp, uint64_t start_epoch,
uint64_t end_epoch) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosBucket::remove_objs_from_index(
const DoutPrefixProvider* dpp,
std::list<rgw_obj_index_key>& objs_to_unlink) {
/* XXX: CHECK: Unlike RadosStore, there is no seperate bucket index table.
* Delete all the object in the list from the object table of this
* bucket
*/
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosBucket::check_index(
const DoutPrefixProvider* dpp,
std::map<RGWObjCategory, RGWStorageStats>& existing_stats,
std::map<RGWObjCategory, RGWStorageStats>& calculated_stats) {
/* XXX: stats not supported yet */
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosBucket::rebuild_index(const DoutPrefixProvider* dpp) {
/* there is no index table in DAOS. Not applicable */
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosBucket::set_tag_timeout(const DoutPrefixProvider* dpp,
uint64_t timeout) {
/* XXX: CHECK: set tag timeout for all the bucket objects? */
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosBucket::purge_instance(const DoutPrefixProvider* dpp) {
/* XXX: CHECK: for DAOS only single instance supported.
* Remove all the objects for that instance? Anything extra needed?
*/
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosBucket::set_acl(const DoutPrefixProvider* dpp,
RGWAccessControlPolicy& acl, optional_yield y) {
ldpp_dout(dpp, 20) << "DEBUG: set_acl" << dendl;
int ret = 0;
bufferlist aclbl;
acls = acl;
acl.encode(aclbl);
Attrs attrs = get_attrs();
attrs[RGW_ATTR_ACL] = aclbl;
return ret;
}
std::unique_ptr<Object> DaosBucket::get_object(const rgw_obj_key& k) {
return std::make_unique<DaosObject>(this->store, k, this);
}
bool compare_rgw_bucket_dir_entry(rgw_bucket_dir_entry& entry1,
rgw_bucket_dir_entry& entry2) {
return (entry1.key < entry2.key);
}
bool compare_multipart_upload(std::unique_ptr<MultipartUpload>& upload1,
std::unique_ptr<MultipartUpload>& upload2) {
return (upload1->get_key() < upload2->get_key());
}
int DaosBucket::list(const DoutPrefixProvider* dpp, ListParams& params, int max,
ListResults& results, optional_yield y) {
ldpp_dout(dpp, 20) << "DEBUG: list bucket=" << get_name() << " max=" << max
<< " params=" << params << dendl;
// End
if (max == 0) {
return 0;
}
int ret = open(dpp);
if (ret != 0) {
return ret;
}
// Init needed structures
vector<struct ds3_object_info> object_infos(max);
uint32_t nobj = object_infos.size();
vector<vector<uint8_t>> values(nobj, vector<uint8_t>(DS3_MAX_ENCODED_LEN));
for (uint32_t i = 0; i < nobj; i++) {
object_infos[i].encoded = values[i].data();
object_infos[i].encoded_length = values[i].size();
}
vector<struct ds3_common_prefix_info> common_prefixes(max);
uint32_t ncp = common_prefixes.size();
char daos_marker[DS3_MAX_KEY_BUFF];
std::strncpy(daos_marker, params.marker.get_oid().c_str(), sizeof(daos_marker));
ret = ds3_bucket_list_obj(&nobj, object_infos.data(), &ncp,
common_prefixes.data(), params.prefix.c_str(),
params.delim.c_str(), daos_marker,
params.list_versions, &results.is_truncated, ds3b);
if (ret != 0) {
ldpp_dout(dpp, 0) << "ERROR: ds3_bucket_list_obj failed, name="
<< get_name() << ", ret=" << ret << dendl;
return ret;
}
object_infos.resize(nobj);
values.resize(nobj);
common_prefixes.resize(ncp);
// Fill common prefixes
for (auto const& cp : common_prefixes) {
results.common_prefixes[cp.prefix] = true;
}
// Decode objs
for (auto const& obj : object_infos) {
bufferlist bl;
rgw_bucket_dir_entry ent;
bl.append(reinterpret_cast<char*>(obj.encoded), obj.encoded_length);
auto iter = bl.cbegin();
ent.decode(iter);
if (params.list_versions || ent.is_visible()) {
results.objs.emplace_back(std::move(ent));
}
}
if (!params.allow_unordered) {
std::sort(results.objs.begin(), results.objs.end(),
compare_rgw_bucket_dir_entry);
}
return ret;
}
int DaosBucket::list_multiparts(
const DoutPrefixProvider* dpp, const string& prefix, string& marker,
const string& delim, const int& max_uploads,
vector<std::unique_ptr<MultipartUpload>>& uploads,
map<string, bool>* common_prefixes, bool* is_truncated) {
ldpp_dout(dpp, 20) << "DEBUG: list_multiparts" << dendl;
// End of uploading
if (max_uploads == 0) {
*is_truncated = false;
return 0;
}
// Init needed structures
vector<struct ds3_multipart_upload_info> multipart_upload_infos(max_uploads);
uint32_t nmp = multipart_upload_infos.size();
vector<vector<uint8_t>> values(nmp, vector<uint8_t>(DS3_MAX_ENCODED_LEN));
for (uint32_t i = 0; i < nmp; i++) {
multipart_upload_infos[i].encoded = values[i].data();
multipart_upload_infos[i].encoded_length = values[i].size();
}
vector<struct ds3_common_prefix_info> cps(max_uploads);
uint32_t ncp = cps.size();
char daos_marker[DS3_MAX_KEY_BUFF];
std::strncpy(daos_marker, marker.c_str(), sizeof(daos_marker));
int ret = ds3_bucket_list_multipart(
get_name().c_str(), &nmp, multipart_upload_infos.data(), &ncp, cps.data(),
prefix.c_str(), delim.c_str(), daos_marker, is_truncated, store->ds3);
multipart_upload_infos.resize(nmp);
values.resize(nmp);
cps.resize(ncp);
// Fill common prefixes
for (auto const& cp : cps) {
(*common_prefixes)[cp.prefix] = true;
}
for (auto const& mp : multipart_upload_infos) {
// Decode the xattr
bufferlist bl;
rgw_bucket_dir_entry ent;
bl.append(reinterpret_cast<char*>(mp.encoded), mp.encoded_length);
auto iter = bl.cbegin();
ent.decode(iter);
string name = ent.key.name;
ACLOwner owner(rgw_user(ent.meta.owner));
owner.set_name(ent.meta.owner_display_name);
uploads.push_back(this->get_multipart_upload(
name, mp.upload_id, std::move(owner), ent.meta.mtime));
}
// Sort uploads
std::sort(uploads.begin(), uploads.end(), compare_multipart_upload);
return ret;
}
int DaosBucket::abort_multiparts(const DoutPrefixProvider* dpp,
CephContext* cct) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
void DaosStore::finalize(void) {
ldout(cctx, 20) << "DEBUG: finalize" << dendl;
int ret;
ret = ds3_disconnect(ds3, nullptr);
if (ret != 0) {
ldout(cctx, 0) << "ERROR: ds3_disconnect() failed: " << ret << dendl;
}
ds3 = nullptr;
ret = ds3_fini();
if (ret != 0) {
ldout(cctx, 0) << "ERROR: daos_fini() failed: " << ret << dendl;
}
}
int DaosStore::initialize(CephContext* cct, const DoutPrefixProvider* dpp) {
ldpp_dout(dpp, 20) << "DEBUG: initialize" << dendl;
int ret = ds3_init();
// DS3 init failed, allow the case where init is already done
if (ret != 0 && ret != DER_ALREADY) {
ldout(cct, 0) << "ERROR: ds3_init() failed: " << ret << dendl;
return ret;
}
// XXX: these params should be taken from config settings and
// cct somehow?
const auto& daos_pool = cct->_conf.get_val<std::string>("daos_pool");
ldout(cct, 20) << "INFO: daos pool: " << daos_pool << dendl;
ret = ds3_connect(daos_pool.c_str(), nullptr, &ds3, nullptr);
if (ret != 0) {
ldout(cct, 0) << "ERROR: ds3_connect() failed: " << ret << dendl;
ds3_fini();
}
return ret;
}
const std::string& DaosZoneGroup::get_endpoint() const {
if (!group.endpoints.empty()) {
return group.endpoints.front();
} else {
// use zonegroup's master zone endpoints
auto z = group.zones.find(group.master_zone);
if (z != group.zones.end() && !z->second.endpoints.empty()) {
return z->second.endpoints.front();
}
}
return empty;
}
bool DaosZoneGroup::placement_target_exists(std::string& target) const {
return !!group.placement_targets.count(target);
}
int DaosZoneGroup::get_placement_target_names(
std::set<std::string>& names) const {
for (const auto& target : group.placement_targets) {
names.emplace(target.second.name);
}
return 0;
}
int DaosZoneGroup::get_placement_tier(const rgw_placement_rule& rule,
std::unique_ptr<PlacementTier>* tier) {
std::map<std::string, RGWZoneGroupPlacementTarget>::const_iterator titer;
titer = group.placement_targets.find(rule.name);
if (titer == group.placement_targets.end()) {
return -ENOENT;
}
const auto& target_rule = titer->second;
std::map<std::string, RGWZoneGroupPlacementTier>::const_iterator ttier;
ttier = target_rule.tier_targets.find(rule.storage_class);
if (ttier == target_rule.tier_targets.end()) {
// not found
return -ENOENT;
}
PlacementTier* t;
t = new DaosPlacementTier(store, ttier->second);
if (!t) return -ENOMEM;
tier->reset(t);
return 0;
}
ZoneGroup& DaosZone::get_zonegroup() { return zonegroup; }
int DaosZone::get_zonegroup(const std::string& id,
std::unique_ptr<ZoneGroup>* group) {
/* XXX: for now only one zonegroup supported */
ZoneGroup* zg;
zg = new DaosZoneGroup(store, zonegroup.get_group());
group->reset(zg);
return 0;
}
const rgw_zone_id& DaosZone::get_id() { return cur_zone_id; }
const std::string& DaosZone::get_name() const {
return zone_params->get_name();
}
bool DaosZone::is_writeable() { return true; }
bool DaosZone::get_redirect_endpoint(std::string* endpoint) { return false; }
bool DaosZone::has_zonegroup_api(const std::string& api) const { return false; }
const std::string& DaosZone::get_current_period_id() {
return current_period->get_id();
}
std::unique_ptr<LuaManager> DaosStore::get_lua_manager() {
return std::make_unique<DaosLuaManager>(this);
}
int DaosObject::get_obj_state(const DoutPrefixProvider* dpp,
RGWObjState** _state, optional_yield y,
bool follow_olh) {
// Get object's metadata (those stored in rgw_bucket_dir_entry)
ldpp_dout(dpp, 20) << "DEBUG: get_obj_state" << dendl;
rgw_bucket_dir_entry ent;
*_state = &state; // state is required even if a failure occurs
int ret = get_dir_entry_attrs(dpp, &ent);
if (ret != 0) {
return ret;
}
// Set object state.
state.exists = true;
state.size = ent.meta.size;
state.accounted_size = ent.meta.size;
state.mtime = ent.meta.mtime;
state.has_attrs = true;
bufferlist etag_bl;
string& etag = ent.meta.etag;
ldpp_dout(dpp, 20) << __func__ << ": object's etag: " << ent.meta.etag
<< dendl;
etag_bl.append(etag);
state.attrset[RGW_ATTR_ETAG] = etag_bl;
return 0;
}
DaosObject::~DaosObject() { close(nullptr); }
int DaosObject::set_obj_attrs(const DoutPrefixProvider* dpp, Attrs* setattrs,
Attrs* delattrs, optional_yield y) {
ldpp_dout(dpp, 20) << "DEBUG: DaosObject::set_obj_attrs()" << dendl;
// TODO handle target_obj
// Get object's metadata (those stored in rgw_bucket_dir_entry)
rgw_bucket_dir_entry ent;
int ret = get_dir_entry_attrs(dpp, &ent);
if (ret != 0) {
return ret;
}
// Update object metadata
Attrs updateattrs = setattrs == nullptr ? attrs : *setattrs;
if (delattrs) {
for (auto const& [attr, attrval] : *delattrs) {
updateattrs.erase(attr);
}
}
ret = set_dir_entry_attrs(dpp, &ent, &updateattrs);
return ret;
}
int DaosObject::get_obj_attrs(optional_yield y, const DoutPrefixProvider* dpp,
rgw_obj* target_obj) {
ldpp_dout(dpp, 20) << "DEBUG: DaosObject::get_obj_attrs()" << dendl;
// TODO handle target_obj
// Get object's metadata (those stored in rgw_bucket_dir_entry)
rgw_bucket_dir_entry ent;
int ret = get_dir_entry_attrs(dpp, &ent, &attrs);
return ret;
}
int DaosObject::modify_obj_attrs(const char* attr_name, bufferlist& attr_val,
optional_yield y,
const DoutPrefixProvider* dpp) {
// Get object's metadata (those stored in rgw_bucket_dir_entry)
ldpp_dout(dpp, 20) << "DEBUG: modify_obj_attrs" << dendl;
rgw_bucket_dir_entry ent;
int ret = get_dir_entry_attrs(dpp, &ent, &attrs);
if (ret != 0) {
return ret;
}
// Update object attrs
set_atomic();
attrs[attr_name] = attr_val;
ret = set_dir_entry_attrs(dpp, &ent, &attrs);
return ret;
}
int DaosObject::delete_obj_attrs(const DoutPrefixProvider* dpp,
const char* attr_name, optional_yield y) {
ldpp_dout(dpp, 20) << "DEBUG: delete_obj_attrs" << dendl;
rgw_obj target = get_obj();
Attrs rmattr;
bufferlist bl;
rmattr[attr_name] = bl;
return set_obj_attrs(dpp, nullptr, &rmattr, y);
}
bool DaosObject::is_expired() {
auto iter = attrs.find(RGW_ATTR_DELETE_AT);
if (iter != attrs.end()) {
utime_t delete_at;
try {
auto bufit = iter->second.cbegin();
decode(delete_at, bufit);
} catch (buffer::error& err) {
ldout(store->ctx(), 0)
<< "ERROR: " << __func__
<< ": failed to decode " RGW_ATTR_DELETE_AT " attr" << dendl;
return false;
}
if (delete_at <= ceph_clock_now() && !delete_at.is_zero()) {
return true;
}
}
return false;
}
// Taken from rgw_rados.cc
void DaosObject::gen_rand_obj_instance_name() {
enum { OBJ_INSTANCE_LEN = 32 };
char buf[OBJ_INSTANCE_LEN + 1];
gen_rand_alphanumeric_no_underscore(store->ctx(), buf, OBJ_INSTANCE_LEN);
state.obj.key.set_instance(buf);
}
int DaosObject::omap_get_vals_by_keys(const DoutPrefixProvider* dpp,
const std::string& oid,
const std::set<std::string>& keys,
Attrs* vals) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosObject::omap_set_val_by_key(const DoutPrefixProvider* dpp,
const std::string& key, bufferlist& val,
bool must_exist, optional_yield y) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosObject::chown(User& new_user, const DoutPrefixProvider* dpp, optional_yield y) {
return 0;
}
std::unique_ptr<MPSerializer> DaosObject::get_serializer(
const DoutPrefixProvider* dpp, const std::string& lock_name) {
return std::make_unique<MPDaosSerializer>(dpp, store, this, lock_name);
}
int DaosObject::transition(Bucket* bucket,
const rgw_placement_rule& placement_rule,
const real_time& mtime, uint64_t olh_epoch,
const DoutPrefixProvider* dpp, optional_yield y) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosObject::transition_to_cloud(
Bucket* bucket, rgw::sal::PlacementTier* tier, rgw_bucket_dir_entry& o,
std::set<std::string>& cloud_targets, CephContext* cct, bool update_object,
const DoutPrefixProvider* dpp, optional_yield y) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
bool DaosObject::placement_rules_match(rgw_placement_rule& r1,
rgw_placement_rule& r2) {
/* XXX: support single default zone and zonegroup for now */
return true;
}
int DaosObject::dump_obj_layout(const DoutPrefixProvider* dpp, optional_yield y,
Formatter* f) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
std::unique_ptr<Object::ReadOp> DaosObject::get_read_op() {
return std::make_unique<DaosObject::DaosReadOp>(this);
}
DaosObject::DaosReadOp::DaosReadOp(DaosObject* _source) : source(_source) {}
int DaosObject::DaosReadOp::prepare(optional_yield y,
const DoutPrefixProvider* dpp) {
ldpp_dout(dpp, 20) << __func__
<< ": bucket=" << source->get_bucket()->get_name()
<< dendl;
if (source->get_bucket()->versioned() && !source->have_instance()) {
// If the bucket is versioned and no version is specified, get the latest
// version
source->set_instance(DS3_LATEST_INSTANCE);
}
rgw_bucket_dir_entry ent;
int ret = source->get_dir_entry_attrs(dpp, &ent);
// Set source object's attrs. The attrs is key/value map and is used
// in send_response_data() to set attributes, including etag.
bufferlist etag_bl;
string& etag = ent.meta.etag;
ldpp_dout(dpp, 20) << __func__ << ": object's etag: " << ent.meta.etag
<< dendl;
etag_bl.append(etag.c_str(), etag.size());
source->get_attrs().emplace(std::move(RGW_ATTR_ETAG), std::move(etag_bl));
source->set_key(ent.key);
source->set_obj_size(ent.meta.size);
ldpp_dout(dpp, 20) << __func__ << ": object's size: " << ent.meta.size
<< dendl;
return ret;
}
int DaosObject::DaosReadOp::read(int64_t off, int64_t end, bufferlist& bl,
optional_yield y,
const DoutPrefixProvider* dpp) {
ldpp_dout(dpp, 20) << __func__ << ": off=" << off << " end=" << end << dendl;
int ret = source->lookup(dpp);
if (ret != 0) {
return ret;
}
// Calculate size, end is inclusive
uint64_t size = end - off + 1;
// Read
ret = source->read(dpp, bl, off, size);
if (ret != 0) {
return ret;
}
return ret;
}
// RGWGetObj::execute() calls ReadOp::iterate() to read object from 'off' to
// 'end'. The returned data is processed in 'cb' which is a chain of
// post-processing filters such as decompression, de-encryption and sending back
// data to client (RGWGetObj_CB::handle_dta which in turn calls
// RGWGetObj::get_data_cb() to send data back.).
//
// POC implements a simple sync version of iterate() function in which it reads
// a block of data each time and call 'cb' for post-processing.
int DaosObject::DaosReadOp::iterate(const DoutPrefixProvider* dpp, int64_t off,
int64_t end, RGWGetDataCB* cb,
optional_yield y) {
ldpp_dout(dpp, 20) << __func__ << ": off=" << off << " end=" << end << dendl;
int ret = source->lookup(dpp);
if (ret != 0) {
return ret;
}
// Calculate size, end is inclusive
uint64_t size = end - off + 1;
// Reserve buffers and read
bufferlist bl;
ret = source->read(dpp, bl, off, size);
if (ret != 0) {
return ret;
}
// Call cb to process returned data.
ldpp_dout(dpp, 20) << __func__ << ": call cb to process data, actual=" << size
<< dendl;
cb->handle_data(bl, off, size);
return ret;
}
int DaosObject::DaosReadOp::get_attr(const DoutPrefixProvider* dpp,
const char* name, bufferlist& dest,
optional_yield y) {
Attrs attrs;
int ret = source->get_dir_entry_attrs(dpp, nullptr, &attrs);
if (!ret) {
return -ENODATA;
}
auto search = attrs.find(name);
if (search == attrs.end()) {
return -ENODATA;
}
dest = search->second;
return 0;
}
std::unique_ptr<Object::DeleteOp> DaosObject::get_delete_op() {
return std::make_unique<DaosObject::DaosDeleteOp>(this);
}
DaosObject::DaosDeleteOp::DaosDeleteOp(DaosObject* _source) : source(_source) {}
// Implementation of DELETE OBJ also requires DaosObject::get_obj_state()
// to retrieve and set object's state from object's metadata.
//
// TODO:
// 1. The POC only deletes the Daos objects. It doesn't handle the
// DeleteOp::params. Delete::delete_obj() in rgw_rados.cc shows how rados
// backend process the params.
// 2. Delete an object when its versioning is turned on.
// 3. Handle empty directories
// 4. Fail when file doesn't exist
int DaosObject::DaosDeleteOp::delete_obj(const DoutPrefixProvider* dpp,
optional_yield y) {
ldpp_dout(dpp, 20) << "DaosDeleteOp::delete_obj "
<< source->get_key().get_oid() << " from "
<< source->get_bucket()->get_name() << dendl;
if (source->get_instance() == "null") {
source->clear_instance();
}
// Open bucket
int ret = 0;
std::string key = source->get_key().get_oid();
DaosBucket* daos_bucket = source->get_daos_bucket();
ret = daos_bucket->open(dpp);
if (ret != 0) {
return ret;
}
// Remove the daos object
ret = ds3_obj_destroy(key.c_str(), daos_bucket->ds3b);
ldpp_dout(dpp, 20) << "DEBUG: ds3_obj_destroy key=" << key << " ret=" << ret
<< dendl;
// result.delete_marker = parent_op.result.delete_marker;
// result.version_id = parent_op.result.version_id;
return ret;
}
int DaosObject::delete_object(const DoutPrefixProvider* dpp, optional_yield y,
bool prevent_versioning) {
ldpp_dout(dpp, 20) << "DEBUG: delete_object" << dendl;
DaosObject::DaosDeleteOp del_op(this);
del_op.params.bucket_owner = bucket->get_info().owner;
del_op.params.versioning_status = bucket->get_info().versioning_status();
return del_op.delete_obj(dpp, y);
}
int DaosObject::copy_object(
User* user, 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,
const ceph::real_time* mod_ptr, const ceph::real_time* unmod_ptr,
bool high_precision_time, const char* if_match, const char* if_nomatch,
AttrsMod attrs_mod, bool copy_if_newer, Attrs& attrs,
RGWObjCategory category, uint64_t olh_epoch,
boost::optional<ceph::real_time> delete_at, std::string* version_id,
std::string* tag, std::string* etag, void (*progress_cb)(off_t, void*),
void* progress_data, const DoutPrefixProvider* dpp, optional_yield y) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosObject::swift_versioning_restore(bool& restored,
const DoutPrefixProvider* dpp) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosObject::swift_versioning_copy(const DoutPrefixProvider* dpp,
optional_yield y) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosObject::lookup(const DoutPrefixProvider* dpp) {
ldpp_dout(dpp, 20) << "DEBUG: lookup" << dendl;
if (is_open()) {
return 0;
}
if (get_instance() == "null") {
clear_instance();
}
int ret = 0;
DaosBucket* daos_bucket = get_daos_bucket();
ret = daos_bucket->open(dpp);
if (ret != 0) {
return ret;
}
ret = ds3_obj_open(get_key().get_oid().c_str(), &ds3o, daos_bucket->ds3b);
if (ret == -ENOENT) {
ldpp_dout(dpp, 20) << "DEBUG: daos object (" << get_bucket()->get_name()
<< ", " << get_key().get_oid()
<< ") does not exist: ret=" << ret << dendl;
} else if (ret != 0) {
ldpp_dout(dpp, 0) << "ERROR: failed to open daos object ("
<< get_bucket()->get_name() << ", " << get_key().get_oid()
<< "): ret=" << ret << dendl;
}
return ret;
}
int DaosObject::create(const DoutPrefixProvider* dpp) {
ldpp_dout(dpp, 20) << "DEBUG: create" << dendl;
if (is_open()) {
return 0;
}
if (get_instance() == "null") {
clear_instance();
}
int ret = 0;
DaosBucket* daos_bucket = get_daos_bucket();
ret = daos_bucket->open(dpp);
if (ret != 0) {
return ret;
}
ret = ds3_obj_create(get_key().get_oid().c_str(), &ds3o, daos_bucket->ds3b);
if (ret != 0) {
ldpp_dout(dpp, 0) << "ERROR: failed to create daos object ("
<< get_bucket()->get_name() << ", " << get_key().get_oid()
<< "): ret=" << ret << dendl;
}
return ret;
}
int DaosObject::close(const DoutPrefixProvider* dpp) {
ldpp_dout(dpp, 20) << "DEBUG: close" << dendl;
if (!is_open()) {
return 0;
}
int ret = ds3_obj_close(ds3o);
ds3o = nullptr;
ldpp_dout(dpp, 20) << "DEBUG: ds3_obj_close ret=" << ret << dendl;
return ret;
}
int DaosObject::write(const DoutPrefixProvider* dpp, bufferlist&& data,
uint64_t offset) {
ldpp_dout(dpp, 20) << "DEBUG: write" << dendl;
uint64_t size = data.length();
int ret = ds3_obj_write(data.c_str(), offset, &size, get_daos_bucket()->ds3b,
ds3o, nullptr);
if (ret != 0) {
ldpp_dout(dpp, 0) << "ERROR: failed to write into daos object ("
<< get_bucket()->get_name() << ", " << get_key().get_oid()
<< "): ret=" << ret << dendl;
}
return ret;
}
int DaosObject::read(const DoutPrefixProvider* dpp, bufferlist& data,
uint64_t offset, uint64_t& size) {
ldpp_dout(dpp, 20) << "DEBUG: read" << dendl;
int ret = ds3_obj_read(data.append_hole(size).c_str(), offset, &size,
get_daos_bucket()->ds3b, ds3o, nullptr);
if (ret != 0) {
ldpp_dout(dpp, 0) << "ERROR: failed to read from daos object ("
<< get_bucket()->get_name() << ", " << get_key().get_oid()
<< "): ret=" << ret << dendl;
}
return ret;
}
// Get the object's dirent and attrs
int DaosObject::get_dir_entry_attrs(const DoutPrefixProvider* dpp,
rgw_bucket_dir_entry* ent,
Attrs* getattrs) {
ldpp_dout(dpp, 20) << "DEBUG: get_dir_entry_attrs" << dendl;
int ret = 0;
vector<uint8_t> value(DS3_MAX_ENCODED_LEN);
uint32_t size = value.size();
if (get_key().ns == RGW_OBJ_NS_MULTIPART) {
struct ds3_multipart_upload_info ui = {.encoded = value.data(),
.encoded_length = size};
ret = ds3_upload_get_info(&ui, bucket->get_name().c_str(),
get_key().get_oid().c_str(), store->ds3);
} else {
ret = lookup(dpp);
if (ret != 0) {
return ret;
}
auto object_info = std::make_unique<struct ds3_object_info>();
object_info->encoded = value.data();
object_info->encoded_length = size;
ret = ds3_obj_get_info(object_info.get(), get_daos_bucket()->ds3b, ds3o);
size = object_info->encoded_length;
}
if (ret != 0) {
ldpp_dout(dpp, 0) << "ERROR: failed to get info of daos object ("
<< get_bucket()->get_name() << ", " << get_key().get_oid()
<< "): ret=" << ret << dendl;
return ret;
}
rgw_bucket_dir_entry dummy_ent;
if (!ent) {
// if ent is not passed, use a dummy ent
ent = &dummy_ent;
}
bufferlist bl;
bl.append(reinterpret_cast<char*>(value.data()), size);
auto iter = bl.cbegin();
ent->decode(iter);
if (getattrs) {
decode(*getattrs, iter);
}
return ret;
}
// Set the object's dirent and attrs
int DaosObject::set_dir_entry_attrs(const DoutPrefixProvider* dpp,
rgw_bucket_dir_entry* ent,
Attrs* setattrs) {
ldpp_dout(dpp, 20) << "DEBUG: set_dir_entry_attrs" << dendl;
int ret = lookup(dpp);
if (ret != 0) {
return ret;
}
// Set defaults
if (!ent) {
// if ent is not passed, return an error
return -EINVAL;
}
if (!setattrs) {
// if setattrs is not passed, use object attrs
setattrs = &attrs;
}
bufferlist wbl;
ent->encode(wbl);
encode(*setattrs, wbl);
// Write rgw_bucket_dir_entry into object xattr
auto object_info = std::make_unique<struct ds3_object_info>();
object_info->encoded = wbl.c_str();
object_info->encoded_length = wbl.length();
ret = ds3_obj_set_info(object_info.get(), get_daos_bucket()->ds3b, ds3o);
if (ret != 0) {
ldpp_dout(dpp, 0) << "ERROR: failed to set info of daos object ("
<< get_bucket()->get_name() << ", " << get_key().get_oid()
<< "): ret=" << ret << dendl;
}
return ret;
}
int DaosObject::mark_as_latest(const DoutPrefixProvider* dpp,
ceph::real_time set_mtime) {
// TODO handle deletion
// TODO understand race conditions
ldpp_dout(dpp, 20) << "DEBUG: mark_as_latest" << dendl;
// Get latest version so far
std::unique_ptr<DaosObject> latest_object = std::make_unique<DaosObject>(
store, rgw_obj_key(get_name(), DS3_LATEST_INSTANCE), get_bucket());
ldpp_dout(dpp, 20) << __func__ << ": key=" << get_key().get_oid()
<< " latest_object_key= "
<< latest_object->get_key().get_oid() << dendl;
int ret = latest_object->lookup(dpp);
if (ret == 0) {
// Get metadata only if file exists
rgw_bucket_dir_entry latest_ent;
Attrs latest_attrs;
ret = latest_object->get_dir_entry_attrs(dpp, &latest_ent, &latest_attrs);
if (ret != 0) {
return ret;
}
// Update flags
latest_ent.flags = rgw_bucket_dir_entry::FLAG_VER;
latest_ent.meta.mtime = set_mtime;
ret = latest_object->set_dir_entry_attrs(dpp, &latest_ent, &latest_attrs);
if (ret != 0) {
return ret;
}
}
// Get or create the link [latest], make it link to the current latest
// version.
ret =
ds3_obj_mark_latest(get_key().get_oid().c_str(), get_daos_bucket()->ds3b);
ldpp_dout(dpp, 20) << "DEBUG: ds3_obj_mark_latest ret=" << ret << dendl;
return ret;
}
DaosAtomicWriter::DaosAtomicWriter(
const DoutPrefixProvider* dpp, optional_yield y,
rgw::sal::Object* obj, DaosStore* _store,
const rgw_user& _owner, const rgw_placement_rule* _ptail_placement_rule,
uint64_t _olh_epoch, const std::string& _unique_tag)
: StoreWriter(dpp, y),
store(_store),
owner(_owner),
ptail_placement_rule(_ptail_placement_rule),
olh_epoch(_olh_epoch),
unique_tag(_unique_tag),
obj(_store, obj->get_key(), obj->get_bucket()) {}
int DaosAtomicWriter::prepare(optional_yield y) {
ldpp_dout(dpp, 20) << "DEBUG: prepare" << dendl;
int ret = obj.create(dpp);
return ret;
}
// TODO: Handle concurrent writes, a unique object id is a possible solution, or
// use DAOS transactions
// XXX: Do we need to accumulate writes as motr does?
int DaosAtomicWriter::process(bufferlist&& data, uint64_t offset) {
ldpp_dout(dpp, 20) << "DEBUG: process" << dendl;
if (data.length() == 0) {
return 0;
}
int ret = 0;
if (!obj.is_open()) {
ret = obj.lookup(dpp);
if (ret != 0) {
return ret;
}
}
// XXX: Combine multiple streams into one as motr does
uint64_t data_size = data.length();
ret = obj.write(dpp, std::move(data), offset);
if (ret == 0) {
total_data_size += data_size;
}
return ret;
}
int DaosAtomicWriter::complete(
size_t accounted_size, const std::string& etag, ceph::real_time* mtime,
ceph::real_time set_mtime, std::map<std::string, bufferlist>& attrs,
ceph::real_time delete_at, const char* if_match, const char* if_nomatch,
const std::string* user_data, rgw_zone_set* zones_trace, bool* canceled,
optional_yield y) {
ldpp_dout(dpp, 20) << "DEBUG: complete" << dendl;
bufferlist bl;
rgw_bucket_dir_entry ent;
int ret;
// Set rgw_bucet_dir_entry. Some of the members of this structure may not
// apply to daos.
//
// Checkout AtomicObjectProcessor::complete() in rgw_putobj_processor.cc
// and RGWRados::Object::Write::write_meta() in rgw_rados.cc for what and
// how to set the dir entry. Only set the basic ones for POC, no ACLs and
// other attrs.
obj.get_key().get_index_key(&ent.key);
ent.meta.size = total_data_size;
ent.meta.accounted_size = accounted_size;
ent.meta.mtime =
real_clock::is_zero(set_mtime) ? ceph::real_clock::now() : set_mtime;
ent.meta.etag = etag;
ent.meta.owner = owner.to_str();
ent.meta.owner_display_name =
obj.get_bucket()->get_owner()->get_display_name();
bool is_versioned = obj.get_bucket()->versioned();
if (is_versioned)
ent.flags =
rgw_bucket_dir_entry::FLAG_VER | rgw_bucket_dir_entry::FLAG_CURRENT;
ldpp_dout(dpp, 20) << __func__ << ": key=" << obj.get_key().get_oid()
<< " etag: " << etag << dendl;
if (user_data) ent.meta.user_data = *user_data;
RGWBucketInfo& info = obj.get_bucket()->get_info();
if (info.obj_lock_enabled() && info.obj_lock.has_rule()) {
auto iter = attrs.find(RGW_ATTR_OBJECT_RETENTION);
if (iter == attrs.end()) {
real_time lock_until_date =
info.obj_lock.get_lock_until_date(ent.meta.mtime);
string mode = info.obj_lock.get_mode();
RGWObjectRetention obj_retention(mode, lock_until_date);
bufferlist retention_bl;
obj_retention.encode(retention_bl);
attrs[RGW_ATTR_OBJECT_RETENTION] = retention_bl;
}
}
ret = obj.set_dir_entry_attrs(dpp, &ent, &attrs);
if (is_versioned) {
ret = obj.mark_as_latest(dpp, set_mtime);
if (ret != 0) {
return ret;
}
}
return ret;
}
int DaosMultipartUpload::abort(const DoutPrefixProvider* dpp,
CephContext* cct) {
// Remove upload from bucket multipart index
ldpp_dout(dpp, 20) << "DEBUG: abort" << dendl;
return ds3_upload_remove(bucket->get_name().c_str(), get_upload_id().c_str(),
store->ds3);
}
std::unique_ptr<rgw::sal::Object> DaosMultipartUpload::get_meta_obj() {
return bucket->get_object(
rgw_obj_key(get_upload_id(), string(), RGW_OBJ_NS_MULTIPART));
}
int DaosMultipartUpload::init(const DoutPrefixProvider* dpp, optional_yield y,
ACLOwner& _owner,
rgw_placement_rule& dest_placement,
rgw::sal::Attrs& attrs) {
ldpp_dout(dpp, 20) << "DEBUG: init" << dendl;
int ret;
std::string oid = mp_obj.get_key();
// Create an initial entry in the bucket. The entry will be
// updated when multipart upload is completed, for example,
// size, etag etc.
bufferlist bl;
rgw_bucket_dir_entry ent;
ent.key.name = oid;
ent.meta.owner = owner.get_id().to_str();
ent.meta.category = RGWObjCategory::MultiMeta;
ent.meta.mtime = ceph::real_clock::now();
multipart_upload_info upload_info;
upload_info.dest_placement = dest_placement;
ent.encode(bl);
encode(attrs, bl);
encode(upload_info, bl);
struct ds3_multipart_upload_info ui;
std::strcpy(ui.upload_id, MULTIPART_UPLOAD_ID_PREFIX);
std::strncpy(ui.key, oid.c_str(), sizeof(ui.key));
ui.encoded = bl.c_str();
ui.encoded_length = bl.length();
int prefix_length = strlen(ui.upload_id);
do {
gen_rand_alphanumeric(store->ctx(), ui.upload_id + prefix_length,
sizeof(ui.upload_id) - 1 - prefix_length);
mp_obj.init(oid, ui.upload_id);
ret = ds3_upload_init(&ui, bucket->get_name().c_str(), store->ds3);
} while (ret == -EEXIST);
if (ret != 0) {
ldpp_dout(dpp, 0) << "ERROR: failed to create multipart upload dir ("
<< bucket->get_name() << "/" << get_upload_id()
<< "): ret=" << ret << dendl;
}
return ret;
}
int DaosMultipartUpload::list_parts(const DoutPrefixProvider* dpp,
CephContext* cct, int num_parts, int marker,
int* next_marker, bool* truncated,
bool assume_unsorted) {
ldpp_dout(dpp, 20) << "DEBUG: list_parts" << dendl;
// Init needed structures
vector<struct ds3_multipart_part_info> multipart_part_infos(num_parts);
uint32_t npart = multipart_part_infos.size();
vector<vector<uint8_t>> values(npart, vector<uint8_t>(DS3_MAX_ENCODED_LEN));
for (uint32_t i = 0; i < npart; i++) {
multipart_part_infos[i].encoded = values[i].data();
multipart_part_infos[i].encoded_length = values[i].size();
}
uint32_t daos_marker = marker;
int ret = ds3_upload_list_parts(
bucket->get_name().c_str(), get_upload_id().c_str(), &npart,
multipart_part_infos.data(), &daos_marker, truncated, store->ds3);
if (ret != 0) {
if (ret == -ENOENT) {
ret = -ERR_NO_SUCH_UPLOAD;
}
return ret;
}
multipart_part_infos.resize(npart);
values.resize(npart);
parts.clear();
for (auto const& pi : multipart_part_infos) {
bufferlist bl;
bl.append(reinterpret_cast<char*>(pi.encoded), pi.encoded_length);
std::unique_ptr<DaosMultipartPart> part =
std::make_unique<DaosMultipartPart>();
auto iter = bl.cbegin();
decode(part->info, iter);
parts[pi.part_num] = std::move(part);
}
if (next_marker) {
*next_marker = daos_marker;
}
return ret;
}
// Heavily copied from rgw_sal_rados.cc
int DaosMultipartUpload::complete(
const DoutPrefixProvider* dpp, optional_yield y, CephContext* cct,
map<int, string>& part_etags, list<rgw_obj_index_key>& remove_objs,
uint64_t& accounted_size, bool& compressed, RGWCompressionInfo& cs_info,
off_t& off, std::string& tag, ACLOwner& owner, uint64_t olh_epoch,
rgw::sal::Object* target_obj) {
ldpp_dout(dpp, 20) << "DEBUG: complete" << dendl;
char final_etag[CEPH_CRYPTO_MD5_DIGESTSIZE];
char final_etag_str[CEPH_CRYPTO_MD5_DIGESTSIZE * 2 + 16];
std::string etag;
bufferlist etag_bl;
MD5 hash;
// Allow use of MD5 digest in FIPS mode for non-cryptographic purposes
hash.SetFlags(EVP_MD_CTX_FLAG_NON_FIPS_ALLOW);
bool truncated;
int ret;
ldpp_dout(dpp, 20) << "DaosMultipartUpload::complete(): enter" << dendl;
int total_parts = 0;
int handled_parts = 0;
int max_parts = 1000;
int marker = 0;
uint64_t min_part_size = cct->_conf->rgw_multipart_min_part_size;
auto etags_iter = part_etags.begin();
rgw::sal::Attrs attrs = target_obj->get_attrs();
do {
ldpp_dout(dpp, 20) << "DaosMultipartUpload::complete(): list_parts()"
<< dendl;
ret = list_parts(dpp, cct, max_parts, marker, &marker, &truncated);
if (ret == -ENOENT) {
ret = -ERR_NO_SUCH_UPLOAD;
}
if (ret != 0) return ret;
total_parts += parts.size();
if (!truncated && total_parts != (int)part_etags.size()) {
ldpp_dout(dpp, 0) << "NOTICE: total parts mismatch: have: " << total_parts
<< " expected: " << part_etags.size() << dendl;
ret = -ERR_INVALID_PART;
return ret;
}
ldpp_dout(dpp, 20) << "DaosMultipartUpload::complete(): parts.size()="
<< parts.size() << dendl;
for (auto obj_iter = parts.begin();
etags_iter != part_etags.end() && obj_iter != parts.end();
++etags_iter, ++obj_iter, ++handled_parts) {
DaosMultipartPart* part =
dynamic_cast<rgw::sal::DaosMultipartPart*>(obj_iter->second.get());
uint64_t part_size = part->get_size();
ldpp_dout(dpp, 20) << "DaosMultipartUpload::complete(): part_size="
<< part_size << dendl;
if (handled_parts < (int)part_etags.size() - 1 &&
part_size < min_part_size) {
ret = -ERR_TOO_SMALL;
return ret;
}
char petag[CEPH_CRYPTO_MD5_DIGESTSIZE];
if (etags_iter->first != (int)obj_iter->first) {
ldpp_dout(dpp, 0) << "NOTICE: parts num mismatch: next requested: "
<< etags_iter->first
<< " next uploaded: " << obj_iter->first << dendl;
ret = -ERR_INVALID_PART;
return ret;
}
string part_etag = rgw_string_unquote(etags_iter->second);
if (part_etag.compare(part->get_etag()) != 0) {
ldpp_dout(dpp, 0) << "NOTICE: etag mismatch: part: "
<< etags_iter->first
<< " etag: " << etags_iter->second << dendl;
ret = -ERR_INVALID_PART;
return ret;
}
hex_to_buf(part->get_etag().c_str(), petag, CEPH_CRYPTO_MD5_DIGESTSIZE);
hash.Update((const unsigned char*)petag, sizeof(petag));
ldpp_dout(dpp, 20) << "DaosMultipartUpload::complete(): calc etag "
<< dendl;
RGWUploadPartInfo& obj_part = part->info;
string oid = mp_obj.get_part(obj_part.num);
rgw_obj src_obj;
src_obj.init_ns(bucket->get_key(), oid, RGW_OBJ_NS_MULTIPART);
bool part_compressed = (obj_part.cs_info.compression_type != "none");
if ((handled_parts > 0) &&
((part_compressed != compressed) ||
(cs_info.compression_type != obj_part.cs_info.compression_type))) {
ldpp_dout(dpp, 0)
<< "ERROR: compression type was changed during multipart upload ("
<< cs_info.compression_type << ">>"
<< obj_part.cs_info.compression_type << ")" << dendl;
ret = -ERR_INVALID_PART;
return ret;
}
ldpp_dout(dpp, 20) << "DaosMultipartUpload::complete(): part compression"
<< dendl;
if (part_compressed) {
int64_t new_ofs; // offset in compression data for new part
if (cs_info.blocks.size() > 0)
new_ofs = cs_info.blocks.back().new_ofs + cs_info.blocks.back().len;
else
new_ofs = 0;
for (const auto& block : obj_part.cs_info.blocks) {
compression_block cb;
cb.old_ofs = block.old_ofs + cs_info.orig_size;
cb.new_ofs = new_ofs;
cb.len = block.len;
cs_info.blocks.push_back(cb);
new_ofs = cb.new_ofs + cb.len;
}
if (!compressed)
cs_info.compression_type = obj_part.cs_info.compression_type;
cs_info.orig_size += obj_part.cs_info.orig_size;
compressed = true;
}
// We may not need to do the following as remove_objs are those
// don't show when listing a bucket. As we store in-progress uploaded
// object's metadata in a separate index, they are not shown when
// listing a bucket.
rgw_obj_index_key remove_key;
src_obj.key.get_index_key(&remove_key);
remove_objs.push_back(remove_key);
off += obj_part.size;
accounted_size += obj_part.accounted_size;
ldpp_dout(dpp, 20) << "DaosMultipartUpload::complete(): off=" << off
<< ", accounted_size = " << accounted_size << dendl;
}
} while (truncated);
hash.Final((unsigned char*)final_etag);
buf_to_hex((unsigned char*)final_etag, sizeof(final_etag), final_etag_str);
snprintf(&final_etag_str[CEPH_CRYPTO_MD5_DIGESTSIZE * 2],
sizeof(final_etag_str) - CEPH_CRYPTO_MD5_DIGESTSIZE * 2, "-%lld",
(long long)part_etags.size());
etag = final_etag_str;
ldpp_dout(dpp, 10) << "calculated etag: " << etag << dendl;
etag_bl.append(etag);
attrs[RGW_ATTR_ETAG] = etag_bl;
if (compressed) {
// write compression attribute to full object
bufferlist tmp;
encode(cs_info, tmp);
attrs[RGW_ATTR_COMPRESSION] = tmp;
}
// Different from rgw_sal_rados.cc starts here
// Read the object's multipart info
bufferlist bl;
uint64_t size = DS3_MAX_ENCODED_LEN;
struct ds3_multipart_upload_info ui = {
.encoded = bl.append_hole(size).c_str(), .encoded_length = size};
ret = ds3_upload_get_info(&ui, bucket->get_name().c_str(),
get_upload_id().c_str(), store->ds3);
ldpp_dout(dpp, 20) << "DEBUG: ds3_upload_get_info entry="
<< bucket->get_name() << "/" << get_upload_id() << dendl;
if (ret != 0) {
if (ret == -ENOENT) {
ret = -ERR_NO_SUCH_UPLOAD;
}
return ret;
}
rgw_bucket_dir_entry ent;
auto iter = bl.cbegin();
ent.decode(iter);
// Update entry data and name
target_obj->get_key().get_index_key(&ent.key);
ent.meta.size = off;
ent.meta.accounted_size = accounted_size;
ldpp_dout(dpp, 20) << "DaosMultipartUpload::complete(): obj size="
<< ent.meta.size
<< " obj accounted size=" << ent.meta.accounted_size
<< dendl;
ent.meta.category = RGWObjCategory::Main;
ent.meta.mtime = ceph::real_clock::now();
bool is_versioned = target_obj->get_bucket()->versioned();
if (is_versioned)
ent.flags =
rgw_bucket_dir_entry::FLAG_VER | rgw_bucket_dir_entry::FLAG_CURRENT;
ent.meta.etag = etag;
// Open object
DaosObject* obj = static_cast<DaosObject*>(target_obj);
ret = obj->create(dpp);
if (ret != 0) {
return ret;
}
// Copy data from parts to object
uint64_t write_off = 0;
for (auto const& [part_num, part] : get_parts()) {
ds3_part_t* ds3p;
ret = ds3_part_open(get_bucket_name().c_str(), get_upload_id().c_str(),
part_num, false, &ds3p, store->ds3);
if (ret != 0) {
return ret;
}
// Reserve buffers and read
uint64_t size = part->get_size();
bufferlist bl;
ret = ds3_part_read(bl.append_hole(size).c_str(), 0, &size, ds3p,
store->ds3, nullptr);
if (ret != 0) {
ds3_part_close(ds3p);
return ret;
}
ldpp_dout(dpp, 20) << "DaosMultipartUpload::complete(): part " << part_num
<< " size is " << size << dendl;
// write to obj
obj->write(dpp, std::move(bl), write_off);
ds3_part_close(ds3p);
write_off += part->get_size();
}
// Set attributes
ret = obj->set_dir_entry_attrs(dpp, &ent, &attrs);
if (is_versioned) {
ret = obj->mark_as_latest(dpp, ent.meta.mtime);
if (ret != 0) {
return ret;
}
}
// Remove upload from bucket multipart index
ret = ds3_upload_remove(get_bucket_name().c_str(), get_upload_id().c_str(),
store->ds3);
return ret;
}
int DaosMultipartUpload::get_info(const DoutPrefixProvider* dpp,
optional_yield y, rgw_placement_rule** rule,
rgw::sal::Attrs* attrs) {
ldpp_dout(dpp, 20) << "DaosMultipartUpload::get_info(): enter" << dendl;
if (!rule && !attrs) {
return 0;
}
if (rule) {
if (!placement.empty()) {
*rule = &placement;
if (!attrs) {
// Don't need attrs, done
return 0;
}
} else {
*rule = nullptr;
}
}
// Read the multipart upload dirent from index
bufferlist bl;
uint64_t size = DS3_MAX_ENCODED_LEN;
struct ds3_multipart_upload_info ui = {
.encoded = bl.append_hole(size).c_str(), .encoded_length = size};
int ret = ds3_upload_get_info(&ui, bucket->get_name().c_str(),
get_upload_id().c_str(), store->ds3);
if (ret != 0) {
if (ret == -ENOENT) {
ret = -ERR_NO_SUCH_UPLOAD;
}
return ret;
}
multipart_upload_info upload_info;
rgw_bucket_dir_entry ent;
Attrs decoded_attrs;
auto iter = bl.cbegin();
ent.decode(iter);
decode(decoded_attrs, iter);
ldpp_dout(dpp, 20) << "DEBUG: decoded_attrs=" << attrs << dendl;
if (attrs) {
*attrs = decoded_attrs;
if (!rule || *rule != nullptr) {
// placement was cached; don't actually read
return 0;
}
}
// Now decode the placement rule
decode(upload_info, iter);
placement = upload_info.dest_placement;
*rule = &placement;
return 0;
}
std::unique_ptr<Writer> DaosMultipartUpload::get_writer(
const DoutPrefixProvider* dpp, optional_yield y,
rgw::sal::Object* obj, const rgw_user& 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="
<< part_num << " head_obj=" << _head_obj << dendl;
return std::make_unique<DaosMultipartWriter>(
dpp, y, this, obj, store, owner, ptail_placement_rule,
part_num, part_num_str);
}
DaosMultipartWriter::~DaosMultipartWriter() {
if (is_open()) ds3_part_close(ds3p);
}
int DaosMultipartWriter::prepare(optional_yield y) {
ldpp_dout(dpp, 20) << "DaosMultipartWriter::prepare(): enter part="
<< part_num_str << dendl;
int ret = ds3_part_open(get_bucket_name().c_str(), upload_id.c_str(),
part_num, true, &ds3p, store->ds3);
if (ret == -ENOENT) {
ret = -ERR_NO_SUCH_UPLOAD;
}
return ret;
}
const std::string& DaosMultipartWriter::get_bucket_name() {
return static_cast<DaosMultipartUpload*>(upload)->get_bucket_name();
}
int DaosMultipartWriter::process(bufferlist&& data, uint64_t offset) {
ldpp_dout(dpp, 20) << "DaosMultipartWriter::process(): enter part="
<< part_num_str << " offset=" << offset << dendl;
if (data.length() == 0) {
return 0;
}
uint64_t size = data.length();
int ret =
ds3_part_write(data.c_str(), offset, &size, ds3p, store->ds3, nullptr);
if (ret == 0) {
// XXX: Combine multiple streams into one as motr does
actual_part_size += size;
} else {
ldpp_dout(dpp, 0) << "ERROR: failed to write into part ("
<< get_bucket_name() << ", " << upload_id << ", "
<< part_num << "): ret=" << ret << dendl;
}
return ret;
}
int DaosMultipartWriter::complete(
size_t accounted_size, const std::string& etag, ceph::real_time* mtime,
ceph::real_time set_mtime, std::map<std::string, bufferlist>& attrs,
ceph::real_time delete_at, const char* if_match, const char* if_nomatch,
const std::string* user_data, rgw_zone_set* zones_trace, bool* canceled,
optional_yield y) {
ldpp_dout(dpp, 20) << "DaosMultipartWriter::complete(): enter part="
<< part_num_str << dendl;
// Add an entry into part index
bufferlist bl;
RGWUploadPartInfo info;
info.num = part_num;
info.etag = etag;
info.size = actual_part_size;
info.accounted_size = accounted_size;
info.modified = real_clock::now();
bool compressed;
int ret = rgw_compression_info_from_attrset(attrs, compressed, info.cs_info);
ldpp_dout(dpp, 20) << "DaosMultipartWriter::complete(): compression ret="
<< ret << dendl;
if (ret != 0) {
ldpp_dout(dpp, 1) << "cannot get compression info" << dendl;
return ret;
}
encode(info, bl);
encode(attrs, bl);
ldpp_dout(dpp, 20) << "DaosMultipartWriter::complete(): entry size"
<< bl.length() << dendl;
struct ds3_multipart_part_info part_info = {.part_num = part_num,
.encoded = bl.c_str(),
.encoded_length = bl.length()};
ret = ds3_part_set_info(&part_info, ds3p, store->ds3, nullptr);
if (ret != 0) {
ldpp_dout(dpp, 0) << "ERROR: failed to set part info (" << get_bucket_name()
<< ", " << upload_id << ", " << part_num
<< "): ret=" << ret << dendl;
if (ret == ENOENT) {
ret = -ERR_NO_SUCH_UPLOAD;
}
}
return ret;
}
std::unique_ptr<RGWRole> DaosStore::get_role(
std::string name, std::string tenant, std::string path,
std::string trust_policy, std::string max_session_duration_str,
std::multimap<std::string, std::string> tags) {
RGWRole* p = nullptr;
return std::unique_ptr<RGWRole>(p);
}
std::unique_ptr<RGWRole> DaosStore::get_role(const RGWRoleInfo& info) {
RGWRole* p = nullptr;
return std::unique_ptr<RGWRole>(p);
}
std::unique_ptr<RGWRole> DaosStore::get_role(std::string id) {
RGWRole* p = nullptr;
return std::unique_ptr<RGWRole>(p);
}
int DaosStore::get_roles(const DoutPrefixProvider* dpp, optional_yield y,
const std::string& path_prefix,
const std::string& tenant,
vector<std::unique_ptr<RGWRole>>& roles) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
std::unique_ptr<RGWOIDCProvider> DaosStore::get_oidc_provider() {
RGWOIDCProvider* p = nullptr;
return std::unique_ptr<RGWOIDCProvider>(p);
}
int DaosStore::get_oidc_providers(
const DoutPrefixProvider* dpp, const std::string& tenant,
vector<std::unique_ptr<RGWOIDCProvider>>& providers) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
std::unique_ptr<MultipartUpload> DaosBucket::get_multipart_upload(
const std::string& oid, std::optional<std::string> upload_id,
ACLOwner owner, ceph::real_time mtime) {
return std::make_unique<DaosMultipartUpload>(store, this, oid, upload_id,
owner, mtime);
}
std::unique_ptr<Writer> DaosStore::get_append_writer(
const DoutPrefixProvider* dpp, optional_yield y,
rgw::sal::Object* obj, const rgw_user& owner,
const rgw_placement_rule* ptail_placement_rule,
const std::string& unique_tag, uint64_t position,
uint64_t* cur_accounted_size) {
DAOS_NOT_IMPLEMENTED_LOG(dpp);
return nullptr;
}
std::unique_ptr<Writer> DaosStore::get_atomic_writer(
const DoutPrefixProvider* dpp, optional_yield y,
rgw::sal::Object* obj, const rgw_user& 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;
return std::make_unique<DaosAtomicWriter>(dpp, y, obj, this,
owner, ptail_placement_rule,
olh_epoch, unique_tag);
}
const std::string& DaosStore::get_compression_type(
const rgw_placement_rule& rule) {
return zone.zone_params->get_compression_type(rule);
}
bool DaosStore::valid_placement(const rgw_placement_rule& rule) {
return zone.zone_params->valid_placement(rule);
}
std::unique_ptr<User> DaosStore::get_user(const rgw_user& u) {
ldout(cctx, 20) << "DEBUG: bucket's user: " << u.to_str() << dendl;
return std::make_unique<DaosUser>(this, u);
}
int DaosStore::get_user_by_access_key(const DoutPrefixProvider* dpp,
const std::string& key, optional_yield y,
std::unique_ptr<User>* user) {
// Initialize ds3_user_info
bufferlist bl;
uint64_t size = DS3_MAX_ENCODED_LEN;
struct ds3_user_info user_info = {.encoded = bl.append_hole(size).c_str(),
.encoded_length = size};
int ret = ds3_user_get_by_key(key.c_str(), &user_info, ds3, nullptr);
if (ret != 0) {
ldpp_dout(dpp, 0) << "Error: ds3_user_get_by_key failed, key=" << key
<< " ret=" << ret << dendl;
return ret;
}
// Decode
DaosUserInfo duinfo;
bufferlist& blr = bl;
auto iter = blr.cbegin();
duinfo.decode(iter);
User* u = new DaosUser(this, duinfo.info);
if (!u) {
return -ENOMEM;
}
user->reset(u);
return 0;
}
int DaosStore::get_user_by_email(const DoutPrefixProvider* dpp,
const std::string& email, optional_yield y,
std::unique_ptr<User>* user) {
// Initialize ds3_user_info
bufferlist bl;
uint64_t size = DS3_MAX_ENCODED_LEN;
struct ds3_user_info user_info = {.encoded = bl.append_hole(size).c_str(),
.encoded_length = size};
int ret = ds3_user_get_by_email(email.c_str(), &user_info, ds3, nullptr);
if (ret != 0) {
ldpp_dout(dpp, 0) << "Error: ds3_user_get_by_email failed, email=" << email
<< " ret=" << ret << dendl;
return ret;
}
// Decode
DaosUserInfo duinfo;
bufferlist& blr = bl;
auto iter = blr.cbegin();
duinfo.decode(iter);
User* u = new DaosUser(this, duinfo.info);
if (!u) {
return -ENOMEM;
}
user->reset(u);
return 0;
}
int DaosStore::get_user_by_swift(const DoutPrefixProvider* dpp,
const std::string& user_str, optional_yield y,
std::unique_ptr<User>* user) {
/* Swift keys and subusers are not supported for now */
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
std::unique_ptr<Object> DaosStore::get_object(const rgw_obj_key& k) {
return std::make_unique<DaosObject>(this, k);
}
inline std::ostream& operator<<(std::ostream& out, const rgw_user* u) {
std::string s;
if (u != nullptr)
u->to_str(s);
else
s = "(nullptr)";
return out << s;
}
int DaosStore::get_bucket(const DoutPrefixProvider* dpp, User* u,
const rgw_bucket& b, std::unique_ptr<Bucket>* bucket,
optional_yield y) {
ldpp_dout(dpp, 20) << "DEBUG: get_bucket1: User: " << u << dendl;
int ret;
Bucket* bp;
bp = new DaosBucket(this, b, u);
ret = bp->load_bucket(dpp, y);
if (ret != 0) {
delete bp;
return ret;
}
bucket->reset(bp);
return 0;
}
int DaosStore::get_bucket(User* u, const RGWBucketInfo& i,
std::unique_ptr<Bucket>* bucket) {
DaosBucket* bp;
bp = new DaosBucket(this, i, u);
/* Don't need to fetch the bucket info, use the provided one */
bucket->reset(bp);
return 0;
}
int DaosStore::get_bucket(const DoutPrefixProvider* dpp, User* u,
const std::string& tenant, const std::string& name,
std::unique_ptr<Bucket>* bucket, optional_yield y) {
ldpp_dout(dpp, 20) << "get_bucket" << dendl;
rgw_bucket b;
b.tenant = tenant;
b.name = name;
return get_bucket(dpp, u, b, bucket, y);
}
bool DaosStore::is_meta_master() { return true; }
int DaosStore::forward_request_to_master(const DoutPrefixProvider* dpp,
User* user, obj_version* objv,
bufferlist& in_data, JSONParser* jp,
req_info& info, optional_yield y) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosStore::forward_iam_request_to_master(const DoutPrefixProvider* dpp,
const RGWAccessKey& key,
obj_version* objv,
bufferlist& in_data,
RGWXMLDecoder::XMLParser* parser,
req_info& info, optional_yield y) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
std::string DaosStore::zone_unique_id(uint64_t unique_num) { return ""; }
std::string DaosStore::zone_unique_trans_id(const uint64_t unique_num) {
return "";
}
int DaosStore::cluster_stat(RGWClusterStat& stats) {
return DAOS_NOT_IMPLEMENTED_LOG(nullptr);
}
std::unique_ptr<Lifecycle> DaosStore::get_lifecycle(void) {
DAOS_NOT_IMPLEMENTED_LOG(nullptr);
return 0;
}
std::unique_ptr<Notification> DaosStore::get_notification(
rgw::sal::Object* obj, rgw::sal::Object* src_obj, struct req_state* s,
rgw::notify::EventType event_type, const std::string* object_name) {
return std::make_unique<DaosNotification>(obj, src_obj, event_type);
}
std::unique_ptr<Notification> DaosStore::get_notification(
const DoutPrefixProvider* dpp, Object* obj, Object* src_obj,
rgw::notify::EventType event_type, rgw::sal::Bucket* _bucket,
std::string& _user_id, std::string& _user_tenant, std::string& _req_id,
optional_yield y) {
ldpp_dout(dpp, 20) << "get_notification" << dendl;
return std::make_unique<DaosNotification>(obj, src_obj, event_type);
}
int DaosStore::log_usage(const DoutPrefixProvider* dpp,
map<rgw_user_bucket, RGWUsageBatch>& usage_info) {
DAOS_NOT_IMPLEMENTED_LOG(dpp);
return 0;
}
int DaosStore::log_op(const DoutPrefixProvider* dpp, string& oid,
bufferlist& bl) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosStore::register_to_service_map(const DoutPrefixProvider* dpp,
const string& daemon_type,
const map<string, string>& meta) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
void DaosStore::get_quota(RGWQuota& quota) {
// XXX: Not handled for the first pass
return;
}
void DaosStore::get_ratelimit(RGWRateLimitInfo& bucket_ratelimit,
RGWRateLimitInfo& user_ratelimit,
RGWRateLimitInfo& anon_ratelimit) {
return;
}
int DaosStore::set_buckets_enabled(const DoutPrefixProvider* dpp,
std::vector<rgw_bucket>& buckets,
bool enabled) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosStore::get_sync_policy_handler(const DoutPrefixProvider* dpp,
std::optional<rgw_zone_id> zone,
std::optional<rgw_bucket> bucket,
RGWBucketSyncPolicyHandlerRef* phandler,
optional_yield y) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
RGWDataSyncStatusManager* DaosStore::get_data_sync_manager(
const rgw_zone_id& source_zone) {
DAOS_NOT_IMPLEMENTED_LOG(nullptr);
return 0;
}
int DaosStore::read_all_usage(
const DoutPrefixProvider* dpp, uint64_t start_epoch, uint64_t end_epoch,
uint32_t max_entries, bool* is_truncated, RGWUsageIter& usage_iter,
map<rgw_user_bucket, rgw_usage_log_entry>& usage) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosStore::trim_all_usage(const DoutPrefixProvider* dpp,
uint64_t start_epoch, uint64_t end_epoch) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosStore::get_config_key_val(string name, bufferlist* bl) {
return DAOS_NOT_IMPLEMENTED_LOG(nullptr);
}
int DaosStore::meta_list_keys_init(const DoutPrefixProvider* dpp,
const string& section, const string& marker,
void** phandle) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
int DaosStore::meta_list_keys_next(const DoutPrefixProvider* dpp, void* handle,
int max, list<string>& keys,
bool* truncated) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
void DaosStore::meta_list_keys_complete(void* handle) { return; }
std::string DaosStore::meta_get_marker(void* handle) { return ""; }
int DaosStore::meta_remove(const DoutPrefixProvider* dpp, string& metadata_key,
optional_yield y) {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
std::string DaosStore::get_cluster_id(const DoutPrefixProvider* dpp,
optional_yield y) {
DAOS_NOT_IMPLEMENTED_LOG(dpp);
return "";
}
} // namespace rgw::sal
extern "C" {
void* newDaosStore(CephContext* cct) {
return new rgw::sal::DaosStore(cct);
}
}
| 80,679 | 31.917177 | 88 |
cc
|
null |
ceph-main/src/rgw/rgw_sal_daos.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=2 sw=2 expandtab ft=cpp
/*
* Ceph - scalable distributed file system
*
* SAL implementation for the CORTX Daos backend
*
* Copyright (C) 2022 Seagate Technology LLC and/or its Affiliates
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#pragma once
#include <daos.h>
#include <daos_s3.h>
#include <uuid/uuid.h>
#include <map>
#include <set>
#include <string>
#include <vector>
#include "rgw_multi.h"
#include "rgw_notify.h"
#include "rgw_oidc_provider.h"
#include "rgw_putobj_processor.h"
#include "rgw_rados.h"
#include "rgw_role.h"
#include "rgw_sal_store.h"
inline bool IsDebuggerAttached() {
#ifdef DEBUG
char buf[4096];
const int status_fd = ::open("/proc/self/status", O_RDONLY);
if (status_fd == -1) return false;
const ssize_t num_read = ::read(status_fd, buf, sizeof(buf) - 1);
::close(status_fd);
if (num_read <= 0) return false;
buf[num_read] = '\0';
constexpr char tracerPidString[] = "TracerPid:";
const auto tracer_pid_ptr = ::strstr(buf, tracerPidString);
if (!tracer_pid_ptr) return false;
for (const char* characterPtr = tracer_pid_ptr + sizeof(tracerPidString) - 1;
characterPtr <= buf + num_read; ++characterPtr) {
if (::isspace(*characterPtr))
continue;
else
return ::isdigit(*characterPtr) != 0 && *characterPtr != '0';
}
#endif // DEBUG
return false;
}
inline void DebugBreak() {
#ifdef DEBUG
// only break into the debugger if the debugger is attached
if (IsDebuggerAttached())
raise(SIGINT); // breaks into GDB and stops, can be continued
#endif // DEBUG
}
inline int NotImplementedLog(const DoutPrefixProvider* ldpp,
const char* filename, int linenumber,
const char* functionname) {
if (ldpp)
ldpp_dout(ldpp, 20) << filename << "(" << linenumber << ") " << functionname
<< ": Not implemented" << dendl;
return 0;
}
inline int NotImplementedGdbBreak(const DoutPrefixProvider* ldpp,
const char* filename, int linenumber,
const char* functionname) {
NotImplementedLog(ldpp, filename, linenumber, functionname);
DebugBreak();
return 0;
}
#define DAOS_NOT_IMPLEMENTED_GDB_BREAK(ldpp) \
NotImplementedGdbBreak(ldpp, __FILE__, __LINE__, __FUNCTION__)
#define DAOS_NOT_IMPLEMENTED_LOG(ldpp) \
NotImplementedLog(ldpp, __FILE__, __LINE__, __FUNCTION__)
namespace rgw::sal {
class DaosStore;
class DaosObject;
#ifdef DEBUG
// Prepends each log entry with the "filename(source_line) function_name". Makes
// it simple to
// associate log entries with the source that generated the log entry
#undef ldpp_dout
#define ldpp_dout(dpp, v) \
if (decltype(auto) pdpp = (dpp); \
pdpp) /* workaround -Wnonnull-compare for 'this' */ \
dout_impl(pdpp->get_cct(), ceph::dout::need_dynamic(pdpp->get_subsys()), v) \
pdpp->gen_prefix(*_dout) \
<< __FILE__ << "(" << __LINE__ << ") " << __FUNCTION__ << " - "
#endif // DEBUG
struct DaosUserInfo {
RGWUserInfo info;
obj_version user_version;
rgw::sal::Attrs attrs;
void encode(bufferlist& bl) const {
ENCODE_START(3, 3, bl);
encode(info, bl);
encode(user_version, bl);
encode(attrs, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(3, bl);
decode(info, bl);
decode(user_version, bl);
decode(attrs, bl);
DECODE_FINISH(bl);
}
};
WRITE_CLASS_ENCODER(DaosUserInfo);
class DaosNotification : public StoreNotification {
public:
DaosNotification(Object* _obj, Object* _src_obj, rgw::notify::EventType _type)
: StoreNotification(_obj, _src_obj, _type) {}
~DaosNotification() = default;
virtual int publish_reserve(const DoutPrefixProvider* dpp,
RGWObjTags* obj_tags = nullptr) override {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
virtual int publish_commit(const DoutPrefixProvider* dpp, uint64_t size,
const ceph::real_time& mtime,
const std::string& etag,
const std::string& version) override {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
};
class DaosUser : public StoreUser {
private:
DaosStore* store;
std::vector<const char*> access_ids;
public:
DaosUser(DaosStore* _st, const rgw_user& _u) : StoreUser(_u), store(_st) {}
DaosUser(DaosStore* _st, const RGWUserInfo& _i) : StoreUser(_i), store(_st) {}
DaosUser(DaosStore* _st) : store(_st) {}
DaosUser(DaosUser& _o) = default;
DaosUser() {}
virtual std::unique_ptr<User> clone() override {
return std::make_unique<DaosUser>(*this);
}
int list_buckets(const DoutPrefixProvider* dpp, const std::string& marker,
const std::string& end_marker, uint64_t max, bool need_stats,
BucketList& buckets, optional_yield y) override;
virtual int create_bucket(
const DoutPrefixProvider* dpp, const rgw_bucket& b,
const std::string& zonegroup_id, rgw_placement_rule& placement_rule,
std::string& swift_ver_location, const RGWQuotaInfo* pquota_info,
const RGWAccessControlPolicy& policy, Attrs& attrs, RGWBucketInfo& info,
obj_version& ep_objv, bool exclusive, bool obj_lock_enabled,
bool* existed, req_info& req_info, std::unique_ptr<Bucket>* bucket,
optional_yield y) override;
virtual int read_attrs(const DoutPrefixProvider* dpp,
optional_yield y) override;
virtual int merge_and_store_attrs(const DoutPrefixProvider* dpp,
Attrs& new_attrs,
optional_yield y) override;
virtual int read_stats(const DoutPrefixProvider* dpp, optional_yield y,
RGWStorageStats* stats,
ceph::real_time* last_stats_sync = nullptr,
ceph::real_time* last_stats_update = nullptr) override;
virtual int read_stats_async(const DoutPrefixProvider* dpp,
RGWGetUserStats_CB* cb) override;
virtual int complete_flush_stats(const DoutPrefixProvider* dpp,
optional_yield y) override;
virtual int read_usage(
const DoutPrefixProvider* dpp, uint64_t start_epoch, uint64_t end_epoch,
uint32_t max_entries, bool* is_truncated, RGWUsageIter& usage_iter,
std::map<rgw_user_bucket, rgw_usage_log_entry>& usage) override;
virtual int trim_usage(const DoutPrefixProvider* dpp, uint64_t start_epoch,
uint64_t end_epoch) override;
virtual int load_user(const DoutPrefixProvider* dpp,
optional_yield y) override;
virtual int store_user(const DoutPrefixProvider* dpp, optional_yield y,
bool exclusive,
RGWUserInfo* old_info = nullptr) override;
virtual int remove_user(const DoutPrefixProvider* dpp,
optional_yield y) override;
/** Read user info without loading it */
int read_user(const DoutPrefixProvider* dpp, std::string name,
DaosUserInfo* duinfo);
std::unique_ptr<struct ds3_user_info> get_encoded_info(bufferlist& bl,
obj_version& obj_ver);
friend class DaosBucket;
};
// RGWBucketInfo and other information that are shown when listing a bucket is
// represented in struct DaosBucketInfo. The structure is encoded and stored
// as the value of the global bucket instance index.
// TODO: compare pros and cons of separating the bucket_attrs (ACLs, tag etc.)
// into a different index.
struct DaosBucketInfo {
RGWBucketInfo info;
obj_version bucket_version;
ceph::real_time mtime;
rgw::sal::Attrs bucket_attrs;
void encode(bufferlist& bl) const {
ENCODE_START(4, 4, bl);
encode(info, bl);
encode(bucket_version, bl);
encode(mtime, bl);
encode(bucket_attrs, bl); // rgw_cache.h example for a map
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(4, bl);
decode(info, bl);
decode(bucket_version, bl);
decode(mtime, bl);
decode(bucket_attrs, bl);
DECODE_FINISH(bl);
}
};
WRITE_CLASS_ENCODER(DaosBucketInfo);
class DaosBucket : public StoreBucket {
private:
DaosStore* store;
RGWAccessControlPolicy acls;
public:
/** Container ds3b handle */
ds3_bucket_t* ds3b = nullptr;
DaosBucket(DaosStore* _st) : store(_st), acls() {}
DaosBucket(const DaosBucket& _daos_bucket)
: store(_daos_bucket.store), acls(), ds3b(nullptr) {
// TODO: deep copy all objects
}
DaosBucket(DaosStore* _st, User* _u) : StoreBucket(_u), store(_st), acls() {}
DaosBucket(DaosStore* _st, const rgw_bucket& _b)
: StoreBucket(_b), store(_st), acls() {}
DaosBucket(DaosStore* _st, const RGWBucketEnt& _e)
: StoreBucket(_e), store(_st), acls() {}
DaosBucket(DaosStore* _st, const RGWBucketInfo& _i)
: StoreBucket(_i), store(_st), acls() {}
DaosBucket(DaosStore* _st, const rgw_bucket& _b, User* _u)
: StoreBucket(_b, _u), store(_st), acls() {}
DaosBucket(DaosStore* _st, const RGWBucketEnt& _e, User* _u)
: StoreBucket(_e, _u), store(_st), acls() {}
DaosBucket(DaosStore* _st, const RGWBucketInfo& _i, User* _u)
: StoreBucket(_i, _u), store(_st), acls() {}
~DaosBucket();
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;
virtual int remove_bucket(const DoutPrefixProvider* dpp, bool delete_children,
bool forward_to_master, req_info* req_info,
optional_yield y) override;
virtual int remove_bucket_bypass_gc(int concurrent_max,
bool keep_index_consistent,
optional_yield y,
const DoutPrefixProvider* dpp) override;
virtual RGWAccessControlPolicy& get_acl(void) override { return acls; }
virtual int set_acl(const DoutPrefixProvider* dpp,
RGWAccessControlPolicy& acl, optional_yield y) override;
virtual int load_bucket(const DoutPrefixProvider* dpp, optional_yield y,
bool get_stats = false) override;
virtual int read_stats(const DoutPrefixProvider* dpp,
const bucket_index_layout_generation& idx_layout,
int shard_id, std::string* bucket_ver,
std::string* master_ver,
std::map<RGWObjCategory, RGWStorageStats>& stats,
std::string* max_marker = nullptr,
bool* syncstopped = nullptr) override;
virtual int read_stats_async(const DoutPrefixProvider* dpp,
const bucket_index_layout_generation& idx_layout,
int shard_id,
RGWGetBucketStats_CB* ctx) override;
virtual int sync_user_stats(const DoutPrefixProvider* dpp,
optional_yield y) override;
virtual int update_container_stats(const DoutPrefixProvider* dpp) override;
virtual int check_bucket_shards(const DoutPrefixProvider* dpp) override;
virtual int chown(const DoutPrefixProvider* dpp, User& new_user,
optional_yield y) override;
virtual int put_info(const DoutPrefixProvider* dpp, bool exclusive,
ceph::real_time mtime) override;
virtual bool is_owner(User* user) 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 merge_and_store_attrs(const DoutPrefixProvider* dpp, Attrs& attrs,
optional_yield y) override;
virtual int try_refresh_info(const DoutPrefixProvider* dpp,
ceph::real_time* pmtime) override;
virtual int read_usage(
const DoutPrefixProvider* dpp, uint64_t start_epoch, uint64_t end_epoch,
uint32_t max_entries, bool* is_truncated, RGWUsageIter& usage_iter,
std::map<rgw_user_bucket, rgw_usage_log_entry>& usage) override;
virtual int trim_usage(const DoutPrefixProvider* dpp, uint64_t start_epoch,
uint64_t end_epoch) override;
virtual int remove_objs_from_index(
const DoutPrefixProvider* dpp,
std::list<rgw_obj_index_key>& objs_to_unlink) override;
virtual int check_index(
const DoutPrefixProvider* dpp,
std::map<RGWObjCategory, RGWStorageStats>& existing_stats,
std::map<RGWObjCategory, RGWStorageStats>& calculated_stats) override;
virtual int rebuild_index(const DoutPrefixProvider* dpp) override;
virtual int set_tag_timeout(const DoutPrefixProvider* dpp,
uint64_t timeout) override;
virtual int purge_instance(const DoutPrefixProvider* dpp) override;
virtual std::unique_ptr<Bucket> clone() override {
return std::make_unique<DaosBucket>(*this);
}
virtual std::unique_ptr<MultipartUpload> get_multipart_upload(
const std::string& oid,
std::optional<std::string> upload_id = std::nullopt, ACLOwner owner = {},
ceph::real_time mtime = real_clock::now()) override;
virtual int list_multiparts(
const DoutPrefixProvider* dpp, const std::string& prefix,
std::string& marker, const std::string& delim, const int& max_uploads,
std::vector<std::unique_ptr<MultipartUpload>>& uploads,
std::map<std::string, bool>* common_prefixes,
bool* is_truncated) override;
virtual int abort_multiparts(const DoutPrefixProvider* dpp,
CephContext* cct) override;
int open(const DoutPrefixProvider* dpp);
int close(const DoutPrefixProvider* dpp);
bool is_open() { return ds3b != nullptr; }
std::unique_ptr<struct ds3_bucket_info> get_encoded_info(
bufferlist& bl, ceph::real_time mtime);
friend class DaosStore;
};
class DaosPlacementTier : public StorePlacementTier {
DaosStore* store;
RGWZoneGroupPlacementTier tier;
public:
DaosPlacementTier(DaosStore* _store, const RGWZoneGroupPlacementTier& _tier)
: store(_store), tier(_tier) {}
virtual ~DaosPlacementTier() = default;
virtual const std::string& get_tier_type() { return tier.tier_type; }
virtual const std::string& get_storage_class() { return tier.storage_class; }
virtual bool retain_head_object() { return tier.retain_head_object; }
RGWZoneGroupPlacementTier& get_rt() { return tier; }
};
class DaosZoneGroup : public StoreZoneGroup {
DaosStore* store;
const RGWZoneGroup group;
std::string empty;
public:
DaosZoneGroup(DaosStore* _store) : store(_store), group() {}
DaosZoneGroup(DaosStore* _store, const RGWZoneGroup& _group)
: store(_store), group(_group) {}
virtual ~DaosZoneGroup() = default;
virtual const std::string& get_id() const override { return group.get_id(); };
virtual const std::string& get_name() const override {
return group.get_name();
};
virtual int equals(const std::string& other_zonegroup) const override {
return group.equals(other_zonegroup);
};
/** Get the endpoint from zonegroup, or from master zone if not set */
virtual const std::string& get_endpoint() const override;
virtual bool placement_target_exists(std::string& target) const override;
virtual bool is_master_zonegroup() const override {
return group.is_master_zonegroup();
};
virtual const std::string& get_api_name() const override {
return group.api_name;
};
virtual int get_placement_target_names(
std::set<std::string>& names) const override;
virtual const std::string& get_default_placement_name() const override {
return group.default_placement.name;
};
virtual int get_hostnames(std::list<std::string>& names) const override {
names = group.hostnames;
return 0;
};
virtual int get_s3website_hostnames(
std::list<std::string>& names) const override {
names = group.hostnames_s3website;
return 0;
};
virtual int get_zone_count() const override { return group.zones.size(); }
virtual int get_placement_tier(const rgw_placement_rule& rule,
std::unique_ptr<PlacementTier>* tier);
virtual std::unique_ptr<ZoneGroup> clone() override {
return std::make_unique<DaosZoneGroup>(store, group);
}
const RGWZoneGroup& get_group() { return group; }
};
class DaosZone : public StoreZone {
protected:
DaosStore* store;
RGWRealm* realm{nullptr};
DaosZoneGroup zonegroup;
RGWZone* zone_public_config{
nullptr}; /* external zone params, e.g., entrypoints, log flags, etc. */
RGWZoneParams* zone_params{
nullptr}; /* internal zone params, e.g., rados pools */
RGWPeriod* current_period{nullptr};
rgw_zone_id cur_zone_id;
public:
DaosZone(DaosStore* _store) : store(_store), zonegroup(_store) {
realm = new RGWRealm();
zone_public_config = new RGWZone();
zone_params = new RGWZoneParams();
current_period = new RGWPeriod();
cur_zone_id = rgw_zone_id(zone_params->get_id());
// XXX: only default and STANDARD supported for now
RGWZonePlacementInfo info;
RGWZoneStorageClasses sc;
sc.set_storage_class("STANDARD", nullptr, nullptr);
info.storage_classes = sc;
zone_params->placement_pools["default"] = info;
}
DaosZone(DaosStore* _store, DaosZoneGroup _zg)
: store(_store), zonegroup(_zg) {
realm = new RGWRealm();
zone_public_config = new RGWZone();
zone_params = new RGWZoneParams();
current_period = new RGWPeriod();
cur_zone_id = rgw_zone_id(zone_params->get_id());
// XXX: only default and STANDARD supported for now
RGWZonePlacementInfo info;
RGWZoneStorageClasses sc;
sc.set_storage_class("STANDARD", nullptr, nullptr);
info.storage_classes = sc;
zone_params->placement_pools["default"] = info;
}
~DaosZone() = default;
virtual std::unique_ptr<Zone> clone() override {
return std::make_unique<DaosZone>(store);
}
virtual ZoneGroup& get_zonegroup() override;
virtual int get_zonegroup(const std::string& id,
std::unique_ptr<ZoneGroup>* zonegroup) override;
virtual const rgw_zone_id& get_id() override;
virtual const std::string& get_name() const override;
virtual bool is_writeable() override;
virtual bool get_redirect_endpoint(std::string* endpoint) override;
virtual bool has_zonegroup_api(const std::string& api) const override;
virtual const std::string& get_current_period_id() override;
virtual const RGWAccessKey& get_system_key() {
return zone_params->system_key;
}
virtual const std::string& get_realm_name() { return realm->get_name(); }
virtual const std::string& get_realm_id() { return realm->get_id(); }
virtual const std::string_view get_tier_type() { return "rgw"; }
friend class DaosStore;
};
class DaosLuaManager : public StoreLuaManager {
DaosStore* store;
public:
DaosLuaManager(DaosStore* _s) : store(_s) {}
virtual ~DaosLuaManager() = default;
virtual int get_script(const DoutPrefixProvider* dpp, optional_yield y,
const std::string& key, std::string& script) override {
DAOS_NOT_IMPLEMENTED_LOG(dpp);
return -ENOENT;
};
virtual int put_script(const DoutPrefixProvider* dpp, optional_yield y,
const std::string& key,
const std::string& script) override {
DAOS_NOT_IMPLEMENTED_LOG(dpp);
return -ENOENT;
};
virtual int del_script(const DoutPrefixProvider* dpp, optional_yield y,
const std::string& key) override {
DAOS_NOT_IMPLEMENTED_LOG(dpp);
return -ENOENT;
};
virtual int add_package(const DoutPrefixProvider* dpp, optional_yield y,
const std::string& package_name) override {
DAOS_NOT_IMPLEMENTED_LOG(dpp);
return -ENOENT;
};
virtual int remove_package(const DoutPrefixProvider* dpp, optional_yield y,
const std::string& package_name) override {
DAOS_NOT_IMPLEMENTED_LOG(dpp);
return -ENOENT;
};
virtual int list_packages(const DoutPrefixProvider* dpp, optional_yield y,
rgw::lua::packages_t& packages) override {
DAOS_NOT_IMPLEMENTED_LOG(dpp);
return -ENOENT;
};
};
class DaosObject : public StoreObject {
private:
DaosStore* store;
RGWAccessControlPolicy acls;
public:
struct DaosReadOp : public StoreReadOp {
private:
DaosObject* source;
public:
DaosReadOp(DaosObject* _source);
virtual int prepare(optional_yield y,
const DoutPrefixProvider* dpp) override;
/*
* Both `read` and `iterate` read up through index `end`
* *inclusive*. The number of bytes that could be returned is
* `end - ofs + 1`.
*/
virtual int read(int64_t off, int64_t end, bufferlist& bl, optional_yield y,
const DoutPrefixProvider* dpp) override;
virtual int iterate(const DoutPrefixProvider* dpp, int64_t off, int64_t end,
RGWGetDataCB* cb, optional_yield y) override;
virtual int get_attr(const DoutPrefixProvider* dpp, const char* name,
bufferlist& dest, optional_yield y) override;
};
struct DaosDeleteOp : public StoreDeleteOp {
private:
DaosObject* source;
public:
DaosDeleteOp(DaosObject* _source);
virtual int delete_obj(const DoutPrefixProvider* dpp,
optional_yield y) override;
};
ds3_obj_t* ds3o = nullptr;
DaosObject() = default;
DaosObject(DaosStore* _st, const rgw_obj_key& _k)
: StoreObject(_k), store(_st), acls() {}
DaosObject(DaosStore* _st, const rgw_obj_key& _k, Bucket* _b)
: StoreObject(_k, _b), store(_st), acls() {}
DaosObject(DaosObject& _o) = default;
virtual ~DaosObject();
virtual int delete_object(const DoutPrefixProvider* dpp, optional_yield y,
bool prevent_versioning = false) override;
virtual int copy_object(
User* user, 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,
const ceph::real_time* mod_ptr, const ceph::real_time* unmod_ptr,
bool high_precision_time, const char* if_match, const char* if_nomatch,
AttrsMod attrs_mod, bool copy_if_newer, Attrs& attrs,
RGWObjCategory category, uint64_t olh_epoch,
boost::optional<ceph::real_time> delete_at, std::string* version_id,
std::string* tag, std::string* etag, void (*progress_cb)(off_t, void*),
void* progress_data, const DoutPrefixProvider* dpp,
optional_yield y) override;
virtual RGWAccessControlPolicy& get_acl(void) override { return acls; }
virtual int set_acl(const RGWAccessControlPolicy& acl) override {
acls = acl;
return 0;
}
virtual int get_obj_state(const DoutPrefixProvider* dpp, RGWObjState** state,
optional_yield y, bool follow_olh = true) override;
virtual int set_obj_attrs(const DoutPrefixProvider* dpp, Attrs* setattrs,
Attrs* delattrs, optional_yield y) override;
virtual int get_obj_attrs(optional_yield y, const DoutPrefixProvider* dpp,
rgw_obj* target_obj = NULL) override;
virtual int modify_obj_attrs(const char* attr_name, bufferlist& attr_val,
optional_yield y,
const DoutPrefixProvider* dpp) override;
virtual int delete_obj_attrs(const DoutPrefixProvider* dpp,
const char* attr_name,
optional_yield y) override;
virtual bool is_expired() override;
virtual void gen_rand_obj_instance_name() override;
virtual std::unique_ptr<Object> clone() override {
return std::make_unique<DaosObject>(*this);
}
virtual std::unique_ptr<MPSerializer> get_serializer(
const DoutPrefixProvider* dpp, const std::string& lock_name) override;
virtual int transition(Bucket* bucket,
const rgw_placement_rule& placement_rule,
const real_time& mtime, uint64_t olh_epoch,
const DoutPrefixProvider* dpp,
optional_yield y) override;
virtual int transition_to_cloud(Bucket* bucket, rgw::sal::PlacementTier* tier,
rgw_bucket_dir_entry& o,
std::set<std::string>& cloud_targets,
CephContext* cct, bool update_object,
const DoutPrefixProvider* dpp,
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;
/* Swift versioning */
virtual int swift_versioning_restore(bool& restored,
const DoutPrefixProvider* dpp) override;
virtual int swift_versioning_copy(const DoutPrefixProvider* dpp,
optional_yield y) override;
/* OPs */
virtual std::unique_ptr<ReadOp> get_read_op() override;
virtual std::unique_ptr<DeleteOp> get_delete_op() override;
/* OMAP */
virtual int omap_get_vals_by_keys(const DoutPrefixProvider* dpp,
const std::string& oid,
const std::set<std::string>& keys,
Attrs* vals) override;
virtual int omap_set_val_by_key(const DoutPrefixProvider* dpp,
const std::string& key, bufferlist& val,
bool must_exist, optional_yield y) override;
virtual int chown(User& new_user, const DoutPrefixProvider* dpp,
optional_yield y) override;
bool is_open() { return ds3o != nullptr; };
// Only lookup the object, do not create
int lookup(const DoutPrefixProvider* dpp);
// Create the object, truncate if exists
int create(const DoutPrefixProvider* dpp);
// Release the daos resources
int close(const DoutPrefixProvider* dpp);
// Write to object starting from offset
int write(const DoutPrefixProvider* dpp, bufferlist&& data, uint64_t offset);
// Read size bytes from object starting from offset
int read(const DoutPrefixProvider* dpp, bufferlist& data, uint64_t offset,
uint64_t& size);
// Get the object's dirent and attrs
int get_dir_entry_attrs(const DoutPrefixProvider* dpp,
rgw_bucket_dir_entry* ent, Attrs* getattrs = nullptr);
// Set the object's dirent and attrs
int set_dir_entry_attrs(const DoutPrefixProvider* dpp,
rgw_bucket_dir_entry* ent, Attrs* setattrs = nullptr);
// Marks this DAOS object as being the latest version and unmarks all other
// versions as latest
int mark_as_latest(const DoutPrefixProvider* dpp, ceph::real_time set_mtime);
// get_bucket casted as DaosBucket*
DaosBucket* get_daos_bucket() {
return static_cast<DaosBucket*>(get_bucket());
}
};
// A placeholder locking class for multipart upload.
class MPDaosSerializer : public StoreMPSerializer {
public:
MPDaosSerializer(const DoutPrefixProvider* dpp, DaosStore* store,
DaosObject* obj, const std::string& lock_name) {}
virtual int try_lock(const DoutPrefixProvider* dpp, utime_t dur,
optional_yield y) override {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
virtual int unlock() override { return DAOS_NOT_IMPLEMENTED_LOG(nullptr); }
};
class DaosAtomicWriter : public StoreWriter {
protected:
rgw::sal::DaosStore* store;
const rgw_user& owner;
const rgw_placement_rule* ptail_placement_rule;
uint64_t olh_epoch;
const std::string& unique_tag;
DaosObject obj;
uint64_t total_data_size = 0; // for total data being uploaded
public:
DaosAtomicWriter(const DoutPrefixProvider* dpp, optional_yield y,
rgw::sal::Object* obj,
DaosStore* _store, const rgw_user& _owner,
const rgw_placement_rule* _ptail_placement_rule,
uint64_t _olh_epoch, const std::string& _unique_tag);
~DaosAtomicWriter() = default;
// prepare to start processing object data
virtual int prepare(optional_yield y) override;
// Process a bufferlist
virtual int process(bufferlist&& data, uint64_t offset) override;
// complete the operation and make its result visible to clients
virtual int complete(size_t accounted_size, const std::string& etag,
ceph::real_time* mtime, ceph::real_time set_mtime,
std::map<std::string, bufferlist>& attrs,
ceph::real_time delete_at, const char* if_match,
const char* if_nomatch, const std::string* user_data,
rgw_zone_set* zones_trace, bool* canceled,
optional_yield y) override;
};
class DaosMultipartWriter : public StoreWriter {
protected:
rgw::sal::DaosStore* store;
MultipartUpload* upload;
std::string upload_id;
// Part parameters.
const uint64_t part_num;
const std::string part_num_str;
uint64_t actual_part_size = 0;
ds3_part_t* ds3p = nullptr;
bool is_open() { return ds3p != nullptr; };
public:
DaosMultipartWriter(const DoutPrefixProvider* dpp, optional_yield y,
MultipartUpload* _upload,
rgw::sal::Object* obj,
DaosStore* _store, const rgw_user& owner,
const rgw_placement_rule* ptail_placement_rule,
uint64_t _part_num, const std::string& part_num_str)
: StoreWriter(dpp, y),
store(_store),
upload(_upload),
upload_id(_upload->get_upload_id()),
part_num(_part_num),
part_num_str(part_num_str) {}
virtual ~DaosMultipartWriter();
// prepare to start processing object data
virtual int prepare(optional_yield y) override;
// Process a bufferlist
virtual int process(bufferlist&& data, uint64_t offset) override;
// complete the operation and make its result visible to clients
virtual int complete(size_t accounted_size, const std::string& etag,
ceph::real_time* mtime, ceph::real_time set_mtime,
std::map<std::string, bufferlist>& attrs,
ceph::real_time delete_at, const char* if_match,
const char* if_nomatch, const std::string* user_data,
rgw_zone_set* zones_trace, bool* canceled,
optional_yield y) override;
const std::string& get_bucket_name();
};
class DaosMultipartPart : public StoreMultipartPart {
protected:
RGWUploadPartInfo info;
public:
DaosMultipartPart() = default;
virtual ~DaosMultipartPart() = default;
virtual uint32_t get_num() { return info.num; }
virtual uint64_t get_size() { return info.accounted_size; }
virtual const std::string& get_etag() { return info.etag; }
virtual ceph::real_time& get_mtime() { return info.modified; }
friend class DaosMultipartUpload;
};
class DaosMultipartUpload : public StoreMultipartUpload {
DaosStore* store;
RGWMPObj mp_obj;
ACLOwner owner;
ceph::real_time mtime;
rgw_placement_rule placement;
RGWObjManifest manifest;
public:
DaosMultipartUpload(DaosStore* _store, Bucket* _bucket,
const std::string& oid,
std::optional<std::string> upload_id, ACLOwner _owner,
ceph::real_time _mtime)
: StoreMultipartUpload(_bucket),
store(_store),
mp_obj(oid, upload_id),
owner(_owner),
mtime(_mtime) {}
virtual ~DaosMultipartUpload() = default;
virtual const std::string& get_meta() const { return mp_obj.get_meta(); }
virtual const std::string& get_key() const { return mp_obj.get_key(); }
virtual const std::string& get_upload_id() const {
return mp_obj.get_upload_id();
}
virtual const ACLOwner& get_owner() const override { return owner; }
virtual ceph::real_time& get_mtime() { return mtime; }
virtual std::unique_ptr<rgw::sal::Object> get_meta_obj() override;
virtual int init(const DoutPrefixProvider* dpp, optional_yield y,
ACLOwner& owner, rgw_placement_rule& dest_placement,
rgw::sal::Attrs& attrs) override;
virtual int list_parts(const DoutPrefixProvider* dpp, CephContext* cct,
int num_parts, int marker, int* next_marker,
bool* truncated,
bool assume_unsorted = false) override;
virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct) override;
virtual int complete(const DoutPrefixProvider* dpp, optional_yield y,
CephContext* cct, std::map<int, std::string>& part_etags,
std::list<rgw_obj_index_key>& remove_objs,
uint64_t& accounted_size, bool& compressed,
RGWCompressionInfo& cs_info, off_t& off,
std::string& tag, ACLOwner& owner, uint64_t olh_epoch,
rgw::sal::Object* target_obj) override;
virtual int get_info(const DoutPrefixProvider* dpp, optional_yield y,
rgw_placement_rule** rule,
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,
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(); }
};
class DaosStore : public StoreDriver {
private:
DaosZone zone;
RGWSyncModuleInstanceRef sync_module;
public:
ds3_t* ds3 = nullptr;
CephContext* cctx;
DaosStore(CephContext* c) : zone(this), cctx(c) {}
~DaosStore() = default;
virtual const std::string get_name() const override { return "daos"; }
virtual std::unique_ptr<User> get_user(const rgw_user& u) override;
virtual std::string get_cluster_id(const DoutPrefixProvider* dpp,
optional_yield y) override;
virtual int get_user_by_access_key(const DoutPrefixProvider* dpp,
const std::string& key, optional_yield y,
std::unique_ptr<User>* user) override;
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;
virtual int get_bucket(const DoutPrefixProvider* dpp, User* u,
const rgw_bucket& b, std::unique_ptr<Bucket>* bucket,
optional_yield y) override;
virtual int get_bucket(User* u, const RGWBucketInfo& i,
std::unique_ptr<Bucket>* bucket) override;
virtual int get_bucket(const DoutPrefixProvider* dpp, User* u,
const std::string& tenant, const std::string& name,
std::unique_ptr<Bucket>* bucket,
optional_yield y) override;
virtual bool is_meta_master() override;
virtual int forward_request_to_master(const DoutPrefixProvider* dpp,
User* user, obj_version* objv,
bufferlist& in_data, JSONParser* jp,
req_info& info,
optional_yield y) override;
virtual int forward_iam_request_to_master(
const DoutPrefixProvider* dpp, const RGWAccessKey& key, obj_version* objv,
bufferlist& in_data, RGWXMLDecoder::XMLParser* parser, req_info& info,
optional_yield y) override;
virtual Zone* get_zone() { return &zone; }
virtual std::string zone_unique_id(uint64_t unique_num) override;
virtual std::string zone_unique_trans_id(const uint64_t unique_num) override;
virtual int cluster_stat(RGWClusterStat& stats) override;
virtual std::unique_ptr<Lifecycle> get_lifecycle(void) override;
virtual std::unique_ptr<Notification> get_notification(
rgw::sal::Object* obj, rgw::sal::Object* src_obj, struct req_state* s,
rgw::notify::EventType event_type, optional_yield y,
const std::string* object_name = nullptr) override;
virtual std::unique_ptr<Notification> get_notification(
const DoutPrefixProvider* dpp, rgw::sal::Object* obj,
rgw::sal::Object* src_obj, rgw::notify::EventType event_type,
rgw::sal::Bucket* _bucket, std::string& _user_id,
std::string& _user_tenant, std::string& _req_id,
optional_yield y) override;
virtual RGWLC* get_rgwlc(void) override { return NULL; }
virtual RGWCoroutinesManagerRegistry* get_cr_registry() override {
return NULL;
}
virtual int log_usage(
const DoutPrefixProvider* dpp,
std::map<rgw_user_bucket, RGWUsageBatch>& usage_info) override;
virtual int log_op(const DoutPrefixProvider* dpp, std::string& oid,
bufferlist& bl) override;
virtual int register_to_service_map(
const DoutPrefixProvider* dpp, const std::string& daemon_type,
const std::map<std::string, std::string>& meta) override;
virtual void get_quota(RGWQuota& quota) override;
virtual void get_ratelimit(RGWRateLimitInfo& bucket_ratelimit,
RGWRateLimitInfo& user_ratelimit,
RGWRateLimitInfo& anon_ratelimit) override;
virtual int set_buckets_enabled(const DoutPrefixProvider* dpp,
std::vector<rgw_bucket>& buckets,
bool enabled) override;
virtual uint64_t get_new_req_id() override {
return DAOS_NOT_IMPLEMENTED_LOG(nullptr);
}
virtual int get_sync_policy_handler(const DoutPrefixProvider* dpp,
std::optional<rgw_zone_id> zone,
std::optional<rgw_bucket> bucket,
RGWBucketSyncPolicyHandlerRef* phandler,
optional_yield y) override;
virtual RGWDataSyncStatusManager* get_data_sync_manager(
const rgw_zone_id& source_zone) override;
virtual void wakeup_meta_sync_shards(std::set<int>& shard_ids) override {
return;
}
virtual void wakeup_data_sync_shards(
const DoutPrefixProvider* dpp, const rgw_zone_id& source_zone,
boost::container::flat_map<
int, boost::container::flat_set<rgw_data_notify_entry>>& shard_ids)
override {
return;
}
virtual int clear_usage(const DoutPrefixProvider* dpp) override {
return DAOS_NOT_IMPLEMENTED_LOG(dpp);
}
virtual int read_all_usage(
const DoutPrefixProvider* dpp, uint64_t start_epoch, uint64_t end_epoch,
uint32_t max_entries, bool* is_truncated, RGWUsageIter& usage_iter,
std::map<rgw_user_bucket, rgw_usage_log_entry>& usage) override;
virtual int trim_all_usage(const DoutPrefixProvider* dpp,
uint64_t start_epoch, uint64_t end_epoch) override;
virtual int get_config_key_val(std::string name, bufferlist* bl) override;
virtual int meta_list_keys_init(const DoutPrefixProvider* dpp,
const std::string& section,
const std::string& marker,
void** phandle) override;
virtual int meta_list_keys_next(const DoutPrefixProvider* dpp, void* handle,
int max, std::list<std::string>& keys,
bool* truncated) override;
virtual void meta_list_keys_complete(void* handle) override;
virtual std::string meta_get_marker(void* handle) override;
virtual int meta_remove(const DoutPrefixProvider* dpp,
std::string& metadata_key, optional_yield y) override;
virtual const RGWSyncModuleInstanceRef& get_sync_module() {
return sync_module;
}
virtual std::string get_host_id() { return ""; }
virtual std::unique_ptr<LuaManager> get_lua_manager() override;
virtual std::unique_ptr<RGWRole> get_role(
std::string name, std::string tenant, std::string path = "",
std::string trust_policy = "", std::string max_session_duration_str = "",
std::multimap<std::string, std::string> tags = {}) override;
virtual std::unique_ptr<RGWRole> get_role(const RGWRoleInfo& info) override;
virtual std::unique_ptr<RGWRole> get_role(std::string id) override;
virtual int get_roles(const DoutPrefixProvider* dpp, optional_yield y,
const std::string& path_prefix,
const std::string& tenant,
std::vector<std::unique_ptr<RGWRole>>& roles) override;
virtual std::unique_ptr<RGWOIDCProvider> get_oidc_provider() override;
virtual int get_oidc_providers(
const DoutPrefixProvider* dpp, const std::string& tenant,
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,
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,
const rgw_placement_rule* ptail_placement_rule, uint64_t olh_epoch,
const std::string& unique_tag) override;
virtual const std::string& get_compression_type(
const rgw_placement_rule& rule) override;
virtual bool valid_placement(const rgw_placement_rule& rule) override;
virtual void finalize(void) override;
virtual CephContext* ctx(void) override { return cctx; }
virtual int initialize(CephContext* cct,
const DoutPrefixProvider* dpp) override;
};
} // namespace rgw::sal
| 43,550 | 40.835735 | 80 |
h
|
null |
ceph-main/src/rgw/rgw_sal_dbstore.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2021 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <errno.h>
#include <stdlib.h>
#include <system_error>
#include <unistd.h>
#include <sstream>
#include "common/Clock.h"
#include "common/errno.h"
#include "rgw_sal.h"
#include "rgw_sal_dbstore.h"
#include "rgw_bucket.h"
#define dout_subsys ceph_subsys_rgw
using namespace std;
namespace rgw::sal {
int DBUser::list_buckets(const DoutPrefixProvider *dpp, const string& marker,
const string& end_marker, uint64_t max, bool need_stats,
BucketList &buckets, optional_yield y)
{
RGWUserBuckets ulist;
bool is_truncated = false;
int ret;
buckets.clear();
ret = store->getDB()->list_buckets(dpp, "", info.user_id, marker, end_marker, max,
need_stats, &ulist, &is_truncated);
if (ret < 0)
return ret;
buckets.set_truncated(is_truncated);
for (const auto& ent : ulist.get_buckets()) {
buckets.add(std::make_unique<DBBucket>(this->store, ent.second, this));
}
return 0;
}
int DBUser::create_bucket(const DoutPrefixProvider *dpp,
const rgw_bucket& b,
const string& zonegroup_id,
rgw_placement_rule& placement_rule,
string& swift_ver_location,
const RGWQuotaInfo * pquota_info,
const RGWAccessControlPolicy& policy,
Attrs& attrs,
RGWBucketInfo& info,
obj_version& ep_objv,
bool exclusive,
bool obj_lock_enabled,
bool *existed,
req_info& req_info,
std::unique_ptr<Bucket>* bucket_out,
optional_yield y)
{
int ret;
bufferlist in_data;
RGWBucketInfo master_info;
rgw_bucket *pmaster_bucket = nullptr;
uint32_t *pmaster_num_shards = nullptr;
real_time creation_time;
std::unique_ptr<Bucket> bucket;
obj_version objv, *pobjv = NULL;
/* If it exists, look it up; otherwise create it */
ret = store->get_bucket(dpp, this, b, &bucket, y);
if (ret < 0 && ret != -ENOENT)
return ret;
if (ret != -ENOENT) {
RGWAccessControlPolicy old_policy(store->ctx());
*existed = true;
if (swift_ver_location.empty()) {
swift_ver_location = bucket->get_info().swift_ver_location;
}
placement_rule.inherit_from(bucket->get_info().placement_rule);
// don't allow changes to the acl policy
/* int r = rgw_op_get_bucket_policy_from_attr(dpp, this, this, bucket->get_attrs(),
&old_policy, y);
if (r >= 0 && old_policy != policy) {
bucket_out->swap(bucket);
return -EEXIST;
}*/
} else {
bucket = std::make_unique<DBBucket>(store, b, this);
*existed = false;
bucket->set_attrs(attrs);
// XXX: For now single default zone and STANDARD storage class
// supported.
placement_rule.name = "default";
placement_rule.storage_class = "STANDARD";
}
/*
* XXX: If not master zone, fwd the request to master zone.
* For now DBStore has single zone.
*/
std::string zid = zonegroup_id;
/* if (zid.empty()) {
zid = svc()->zone->get_zonegroup().get_id();
} */
if (*existed) {
rgw_placement_rule selected_placement_rule;
/* XXX: Handle this when zone is implemented
ret = svc()->zone->select_bucket_placement(this.get_info(),
zid, placement_rule,
&selected_placement_rule, nullptr, y);
if (selected_placement_rule != info.placement_rule) {
ret = -EEXIST;
bucket_out->swap(bucket);
return ret;
} */
} else {
/* XXX: We may not need to send all these params. Cleanup the unused ones */
ret = store->getDB()->create_bucket(dpp, this->get_info(), bucket->get_key(),
zid, placement_rule, swift_ver_location, pquota_info,
attrs, info, pobjv, &ep_objv, creation_time,
pmaster_bucket, pmaster_num_shards, y, exclusive);
if (ret == -EEXIST) {
*existed = true;
ret = 0;
} else if (ret != 0) {
return ret;
}
}
bucket->set_version(ep_objv);
bucket->get_info() = info;
bucket_out->swap(bucket);
return ret;
}
int DBUser::read_attrs(const DoutPrefixProvider* dpp, optional_yield y)
{
int ret;
ret = store->getDB()->get_user(dpp, string("user_id"), get_id().id, info, &attrs,
&objv_tracker);
return ret;
}
int DBUser::read_stats(const DoutPrefixProvider *dpp,
optional_yield y, RGWStorageStats* stats,
ceph::real_time *last_stats_sync,
ceph::real_time *last_stats_update)
{
return 0;
}
/* stats - Not for first pass */
int DBUser::read_stats_async(const DoutPrefixProvider *dpp, RGWGetUserStats_CB *cb)
{
return 0;
}
int DBUser::complete_flush_stats(const DoutPrefixProvider *dpp, optional_yield y)
{
return 0;
}
int DBUser::read_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch, uint32_t max_entries,
bool *is_truncated, RGWUsageIter& usage_iter,
map<rgw_user_bucket, rgw_usage_log_entry>& usage)
{
return 0;
}
int DBUser::trim_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch, optional_yield y)
{
return 0;
}
int DBUser::load_user(const DoutPrefixProvider *dpp, optional_yield y)
{
int ret = 0;
ret = store->getDB()->get_user(dpp, string("user_id"), get_id().id, info, &attrs,
&objv_tracker);
return ret;
}
int DBUser::merge_and_store_attrs(const DoutPrefixProvider* dpp, Attrs& new_attrs, optional_yield y)
{
for(auto& it : new_attrs) {
attrs[it.first] = it.second;
}
return store_user(dpp, y, false);
}
int DBUser::store_user(const DoutPrefixProvider* dpp, optional_yield y, bool exclusive, RGWUserInfo* old_info)
{
int ret = 0;
ret = store->getDB()->store_user(dpp, info, exclusive, &attrs, &objv_tracker, old_info);
return ret;
}
int DBUser::remove_user(const DoutPrefixProvider* dpp, optional_yield y)
{
int ret = 0;
ret = store->getDB()->remove_user(dpp, info, &objv_tracker);
return ret;
}
int DBUser::verify_mfa(const std::string& mfa_str, bool* verified, const DoutPrefixProvider *dpp, optional_yield y)
{
*verified = false;
return 0;
}
int DBBucket::remove_bucket(const DoutPrefixProvider *dpp, bool delete_children, bool forward_to_master, req_info* req_info, optional_yield y)
{
int ret;
ret = load_bucket(dpp, y);
if (ret < 0)
return ret;
/* XXX: handle delete_children */
if (!delete_children) {
/* Check if there are any objects */
rgw::sal::Bucket::ListParams params;
params.list_versions = true;
params.allow_unordered = true;
rgw::sal::Bucket::ListResults results;
results.objs.clear();
ret = list(dpp, params, 2, results, null_yield);
if (ret < 0) {
ldpp_dout(dpp, 20) << __func__ << ": Bucket list objects returned " <<
ret << dendl;
return ret;
}
if (!results.objs.empty()) {
ret = -ENOTEMPTY;
ldpp_dout(dpp, -1) << __func__ << ": Bucket Not Empty.. returning " <<
ret << dendl;
return ret;
}
}
ret = store->getDB()->remove_bucket(dpp, info);
return ret;
}
int DBBucket::remove_bucket_bypass_gc(int concurrent_max, bool
keep_index_consistent,
optional_yield y, const
DoutPrefixProvider *dpp) {
return 0;
}
int DBBucket::load_bucket(const DoutPrefixProvider *dpp, optional_yield y, bool get_stats)
{
int ret = 0;
ret = store->getDB()->get_bucket_info(dpp, string("name"), "", info, &attrs,
&mtime, &bucket_version);
return ret;
}
/* stats - Not for first pass */
int DBBucket::read_stats(const DoutPrefixProvider *dpp,
const bucket_index_layout_generation& idx_layout,
int shard_id,
std::string *bucket_ver, std::string *master_ver,
std::map<RGWObjCategory, RGWStorageStats>& stats,
std::string *max_marker, bool *syncstopped)
{
return 0;
}
int DBBucket::read_stats_async(const DoutPrefixProvider *dpp, const bucket_index_layout_generation& idx_layout, int shard_id, RGWGetBucketStats_CB *ctx)
{
return 0;
}
int DBBucket::sync_user_stats(const DoutPrefixProvider *dpp, optional_yield y)
{
return 0;
}
int DBBucket::update_container_stats(const DoutPrefixProvider *dpp, optional_yield y)
{
return 0;
}
int DBBucket::check_bucket_shards(const DoutPrefixProvider *dpp, optional_yield y)
{
return 0;
}
int DBBucket::chown(const DoutPrefixProvider *dpp, User& new_user, optional_yield y)
{
int ret;
ret = store->getDB()->update_bucket(dpp, "owner", info, false, &(new_user.get_id()), nullptr, nullptr, nullptr);
return ret;
}
int DBBucket::put_info(const DoutPrefixProvider *dpp, bool exclusive, ceph::real_time _mtime, optional_yield y)
{
int ret;
ret = store->getDB()->update_bucket(dpp, "info", info, exclusive, nullptr, nullptr, &_mtime, &info.objv_tracker);
return ret;
}
/* Make sure to call get_bucket_info() if you need it first */
bool DBBucket::is_owner(User* user)
{
return (info.owner.compare(user->get_id()) == 0);
}
int DBBucket::check_empty(const DoutPrefixProvider *dpp, optional_yield y)
{
/* XXX: Check if bucket contains any objects */
return 0;
}
int DBBucket::check_quota(const DoutPrefixProvider *dpp, RGWQuota& quota, uint64_t obj_size,
optional_yield y, bool check_size_only)
{
/* Not Handled in the first pass as stats are also needed */
return 0;
}
int DBBucket::merge_and_store_attrs(const DoutPrefixProvider *dpp, Attrs& new_attrs, optional_yield y)
{
int ret = 0;
for(auto& it : new_attrs) {
attrs[it.first] = it.second;
}
/* XXX: handle has_instance_obj like in set_bucket_instance_attrs() */
ret = store->getDB()->update_bucket(dpp, "attrs", info, false, nullptr, &new_attrs, nullptr, &get_info().objv_tracker);
return ret;
}
int DBBucket::try_refresh_info(const DoutPrefixProvider *dpp, ceph::real_time *pmtime, optional_yield y)
{
int ret = 0;
ret = store->getDB()->get_bucket_info(dpp, string("name"), "", info, &attrs,
pmtime, &bucket_version);
return ret;
}
/* XXX: usage and stats not supported in the first pass */
int DBBucket::read_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch,
uint32_t max_entries, bool *is_truncated,
RGWUsageIter& usage_iter,
map<rgw_user_bucket, rgw_usage_log_entry>& usage)
{
return 0;
}
int DBBucket::trim_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch, optional_yield y)
{
return 0;
}
int DBBucket::remove_objs_from_index(const DoutPrefixProvider *dpp, std::list<rgw_obj_index_key>& objs_to_unlink)
{
/* XXX: CHECK: Unlike RadosStore, there is no seperate bucket index table.
* Delete all the object in the list from the object table of this
* bucket
*/
return 0;
}
int DBBucket::check_index(const DoutPrefixProvider *dpp, std::map<RGWObjCategory, RGWStorageStats>& existing_stats, std::map<RGWObjCategory, RGWStorageStats>& calculated_stats)
{
/* XXX: stats not supported yet */
return 0;
}
int DBBucket::rebuild_index(const DoutPrefixProvider *dpp)
{
/* there is no index table in dbstore. Not applicable */
return 0;
}
int DBBucket::set_tag_timeout(const DoutPrefixProvider *dpp, uint64_t timeout)
{
/* XXX: CHECK: set tag timeout for all the bucket objects? */
return 0;
}
int DBBucket::purge_instance(const DoutPrefixProvider *dpp, optional_yield y)
{
/* XXX: CHECK: for dbstore only single instance supported.
* Remove all the objects for that instance? Anything extra needed?
*/
return 0;
}
int DBBucket::set_acl(const DoutPrefixProvider *dpp, RGWAccessControlPolicy &acl, optional_yield y)
{
int ret = 0;
bufferlist aclbl;
acls = acl;
acl.encode(aclbl);
Attrs attrs = get_attrs();
attrs[RGW_ATTR_ACL] = aclbl;
ret = store->getDB()->update_bucket(dpp, "attrs", info, false, &(acl.get_owner().get_id()), &attrs, nullptr, nullptr);
return ret;
}
std::unique_ptr<Object> DBBucket::get_object(const rgw_obj_key& k)
{
return std::make_unique<DBObject>(this->store, k, this);
}
int DBBucket::list(const DoutPrefixProvider *dpp, ListParams& params, int max, ListResults& results, optional_yield y)
{
int ret = 0;
results.objs.clear();
DB::Bucket target(store->getDB(), get_info());
DB::Bucket::List list_op(&target);
list_op.params.prefix = params.prefix;
list_op.params.delim = params.delim;
list_op.params.marker = params.marker;
list_op.params.ns = params.ns;
list_op.params.end_marker = params.end_marker;
list_op.params.ns = params.ns;
list_op.params.enforce_ns = params.enforce_ns;
list_op.params.access_list_filter = params.access_list_filter;
list_op.params.force_check_filter = params.force_check_filter;
list_op.params.list_versions = params.list_versions;
list_op.params.allow_unordered = params.allow_unordered;
results.objs.clear();
ret = list_op.list_objects(dpp, max, &results.objs, &results.common_prefixes, &results.is_truncated);
if (ret >= 0) {
results.next_marker = list_op.get_next_marker();
params.marker = results.next_marker;
}
return ret;
}
std::unique_ptr<MultipartUpload> DBBucket::get_multipart_upload(
const std::string& oid,
std::optional<std::string> upload_id,
ACLOwner owner, ceph::real_time mtime) {
return std::make_unique<DBMultipartUpload>(this->store, this, oid, upload_id,
std::move(owner), mtime);
}
int DBBucket::list_multiparts(const DoutPrefixProvider *dpp,
const string& prefix,
string& marker,
const string& delim,
const int& max_uploads,
vector<std::unique_ptr<MultipartUpload>>& uploads,
map<string, bool> *common_prefixes,
bool *is_truncated, optional_yield y) {
return 0;
}
int DBBucket::abort_multiparts(const DoutPrefixProvider* dpp,
CephContext* cct, optional_yield y) {
return 0;
}
void DBStore::finalize(void)
{
if (dbsm)
dbsm->destroyAllHandles();
}
const std::string& DBZoneGroup::get_endpoint() const {
if (!group->endpoints.empty()) {
return group->endpoints.front();
} else {
// use zonegroup's master zone endpoints
auto z = group->zones.find(group->master_zone);
if (z != group->zones.end() && !z->second.endpoints.empty()) {
return z->second.endpoints.front();
}
}
return empty;
}
bool DBZoneGroup::placement_target_exists(std::string& target) const {
return !!group->placement_targets.count(target);
}
int DBZoneGroup::get_placement_target_names(std::set<std::string>& names) const {
for (const auto& target : group->placement_targets) {
names.emplace(target.second.name);
}
return 0;
}
ZoneGroup& DBZone::get_zonegroup()
{
return *zonegroup;
}
const RGWZoneParams& DBZone::get_rgw_params()
{
return *zone_params;
}
const std::string& DBZone::get_id()
{
return zone_params->get_id();
}
const std::string& DBZone::get_name() const
{
return zone_params->get_name();
}
bool DBZone::is_writeable()
{
return true;
}
bool DBZone::get_redirect_endpoint(std::string* endpoint)
{
return false;
}
bool DBZone::has_zonegroup_api(const std::string& api) const
{
return false;
}
const std::string& DBZone::get_current_period_id()
{
return current_period->get_id();
}
const RGWAccessKey& DBZone::get_system_key()
{
return zone_params->system_key;
}
const std::string& DBZone::get_realm_name()
{
return realm->get_name();
}
const std::string& DBZone::get_realm_id()
{
return realm->get_id();
}
RGWBucketSyncPolicyHandlerRef DBZone::get_sync_policy_handler()
{
return nullptr;
}
std::unique_ptr<LuaManager> DBStore::get_lua_manager()
{
return std::make_unique<DBLuaManager>(this);
}
int DBObject::get_obj_state(const DoutPrefixProvider* dpp, RGWObjState **pstate, optional_yield y, bool follow_olh)
{
RGWObjState* astate;
DB::Object op_target(store->getDB(), get_bucket()->get_info(), get_obj());
int ret = op_target.get_obj_state(dpp, get_bucket()->get_info(), get_obj(), follow_olh, &astate);
if (ret < 0) {
return ret;
}
/* Don't overwrite obj, atomic, or prefetch */
rgw_obj obj = get_obj();
bool is_atomic = state.is_atomic;
bool prefetch_data = state.prefetch_data;
state = *astate;
*pstate = &state;
state.obj = obj;
state.is_atomic = is_atomic;
state.prefetch_data = prefetch_data;
return ret;
}
int DBObject::read_attrs(const DoutPrefixProvider* dpp, DB::Object::Read &read_op, optional_yield y, rgw_obj* target_obj)
{
read_op.params.attrs = &state.attrset;
read_op.params.target_obj = target_obj;
read_op.params.obj_size = &state.size;
read_op.params.lastmod = &state.mtime;
return read_op.prepare(dpp);
}
int DBObject::set_obj_attrs(const DoutPrefixProvider* dpp, Attrs* setattrs, Attrs* delattrs, optional_yield y)
{
Attrs empty;
DB::Object op_target(store->getDB(),
get_bucket()->get_info(), get_obj());
return op_target.set_attrs(dpp, setattrs ? *setattrs : empty, delattrs);
}
int DBObject::get_obj_attrs(optional_yield y, const DoutPrefixProvider* dpp, rgw_obj* target_obj)
{
DB::Object op_target(store->getDB(), get_bucket()->get_info(), get_obj());
DB::Object::Read read_op(&op_target);
return read_attrs(dpp, read_op, y, target_obj);
}
int DBObject::modify_obj_attrs(const char* attr_name, bufferlist& attr_val, optional_yield y, const DoutPrefixProvider* dpp)
{
rgw_obj target = get_obj();
int r = get_obj_attrs(y, dpp, &target);
if (r < 0) {
return r;
}
set_atomic();
state.attrset[attr_name] = attr_val;
return set_obj_attrs(dpp, &state.attrset, nullptr, y);
}
int DBObject::delete_obj_attrs(const DoutPrefixProvider* dpp, const char* attr_name, optional_yield y)
{
Attrs rmattr;
bufferlist bl;
set_atomic();
rmattr[attr_name] = bl;
return set_obj_attrs(dpp, nullptr, &rmattr, y);
}
bool DBObject::is_expired() {
return false;
}
void DBObject::gen_rand_obj_instance_name()
{
store->getDB()->gen_rand_obj_instance_name(&state.obj.key);
}
int DBObject::omap_get_vals_by_keys(const DoutPrefixProvider *dpp, const std::string& oid,
const std::set<std::string>& keys,
Attrs* vals)
{
DB::Object op_target(store->getDB(),
get_bucket()->get_info(), get_obj());
return op_target.obj_omap_get_vals_by_keys(dpp, oid, keys, vals);
}
int DBObject::omap_set_val_by_key(const DoutPrefixProvider *dpp, const std::string& key, bufferlist& val,
bool must_exist, optional_yield y)
{
DB::Object op_target(store->getDB(),
get_bucket()->get_info(), get_obj());
return op_target.obj_omap_set_val_by_key(dpp, key, val, must_exist);
}
int DBObject::chown(User& new_user, const DoutPrefixProvider* dpp, optional_yield y)
{
return 0;
}
std::unique_ptr<MPSerializer> DBObject::get_serializer(const DoutPrefixProvider *dpp,
const std::string& lock_name)
{
return std::make_unique<MPDBSerializer>(dpp, store, this, lock_name);
}
int DBObject::transition(Bucket* bucket,
const rgw_placement_rule& placement_rule,
const real_time& mtime,
uint64_t olh_epoch,
const DoutPrefixProvider* dpp,
optional_yield y)
{
DB::Object op_target(store->getDB(),
get_bucket()->get_info(), get_obj());
return op_target.transition(dpp, placement_rule, mtime, olh_epoch);
}
bool DBObject::placement_rules_match(rgw_placement_rule& r1, rgw_placement_rule& r2)
{
/* XXX: support single default zone and zonegroup for now */
return true;
}
int DBObject::dump_obj_layout(const DoutPrefixProvider *dpp, optional_yield y, Formatter* f)
{
return 0;
}
std::unique_ptr<Object::ReadOp> DBObject::get_read_op()
{
return std::make_unique<DBObject::DBReadOp>(this, nullptr);
}
DBObject::DBReadOp::DBReadOp(DBObject *_source, RGWObjectCtx *_rctx) :
source(_source),
rctx(_rctx),
op_target(_source->store->getDB(),
_source->get_bucket()->get_info(),
_source->get_obj()),
parent_op(&op_target)
{ }
int DBObject::DBReadOp::prepare(optional_yield y, const DoutPrefixProvider* dpp)
{
uint64_t obj_size;
parent_op.conds.mod_ptr = params.mod_ptr;
parent_op.conds.unmod_ptr = params.unmod_ptr;
parent_op.conds.high_precision_time = params.high_precision_time;
parent_op.conds.mod_zone_id = params.mod_zone_id;
parent_op.conds.mod_pg_ver = params.mod_pg_ver;
parent_op.conds.if_match = params.if_match;
parent_op.conds.if_nomatch = params.if_nomatch;
parent_op.params.lastmod = params.lastmod;
parent_op.params.target_obj = params.target_obj;
parent_op.params.obj_size = &obj_size;
parent_op.params.attrs = &source->get_attrs();
int ret = parent_op.prepare(dpp);
if (ret < 0)
return ret;
source->set_key(parent_op.state.obj.key);
source->set_obj_size(obj_size);
return ret;
}
int DBObject::DBReadOp::read(int64_t ofs, int64_t end, bufferlist& bl, optional_yield y, const DoutPrefixProvider* dpp)
{
return parent_op.read(ofs, end, bl, dpp);
}
int DBObject::DBReadOp::get_attr(const DoutPrefixProvider* dpp, const char* name, bufferlist& dest, optional_yield y)
{
return parent_op.get_attr(dpp, name, dest);
}
std::unique_ptr<Object::DeleteOp> DBObject::get_delete_op()
{
return std::make_unique<DBObject::DBDeleteOp>(this);
}
DBObject::DBDeleteOp::DBDeleteOp(DBObject *_source) :
source(_source),
op_target(_source->store->getDB(),
_source->get_bucket()->get_info(),
_source->get_obj()),
parent_op(&op_target)
{ }
int DBObject::DBDeleteOp::delete_obj(const DoutPrefixProvider* dpp, optional_yield y)
{
parent_op.params.bucket_owner = params.bucket_owner.get_id();
parent_op.params.versioning_status = params.versioning_status;
parent_op.params.obj_owner = params.obj_owner;
parent_op.params.olh_epoch = params.olh_epoch;
parent_op.params.marker_version_id = params.marker_version_id;
parent_op.params.bilog_flags = params.bilog_flags;
parent_op.params.remove_objs = params.remove_objs;
parent_op.params.expiration_time = params.expiration_time;
parent_op.params.unmod_since = params.unmod_since;
parent_op.params.mtime = params.mtime;
parent_op.params.high_precision_time = params.high_precision_time;
parent_op.params.zones_trace = params.zones_trace;
parent_op.params.abortmp = params.abortmp;
parent_op.params.parts_accounted_size = params.parts_accounted_size;
int ret = parent_op.delete_obj(dpp);
if (ret < 0)
return ret;
result.delete_marker = parent_op.result.delete_marker;
result.version_id = parent_op.result.version_id;
return ret;
}
int DBObject::delete_object(const DoutPrefixProvider* dpp, optional_yield y, bool prevent_versioning)
{
DB::Object del_target(store->getDB(), bucket->get_info(), get_obj());
DB::Object::Delete del_op(&del_target);
del_op.params.bucket_owner = bucket->get_info().owner;
del_op.params.versioning_status = bucket->get_info().versioning_status();
return del_op.delete_obj(dpp);
}
int DBObject::copy_object(User* user,
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,
const ceph::real_time* mod_ptr,
const ceph::real_time* unmod_ptr,
bool high_precision_time,
const char* if_match,
const char* if_nomatch,
AttrsMod attrs_mod,
bool copy_if_newer,
Attrs& attrs,
RGWObjCategory category,
uint64_t olh_epoch,
boost::optional<ceph::real_time> delete_at,
std::string* version_id,
std::string* tag,
std::string* etag,
void (*progress_cb)(off_t, void *),
void* progress_data,
const DoutPrefixProvider* dpp,
optional_yield y)
{
return 0;
}
int DBObject::DBReadOp::iterate(const DoutPrefixProvider* dpp, int64_t ofs, int64_t end, RGWGetDataCB* cb, optional_yield y)
{
return parent_op.iterate(dpp, ofs, end, cb);
}
int DBObject::swift_versioning_restore(bool& restored,
const DoutPrefixProvider* dpp, optional_yield y)
{
return 0;
}
int DBObject::swift_versioning_copy(const DoutPrefixProvider* dpp,
optional_yield y)
{
return 0;
}
int DBMultipartUpload::abort(const DoutPrefixProvider *dpp, CephContext *cct, optional_yield y)
{
std::unique_ptr<rgw::sal::Object> meta_obj = get_meta_obj();
meta_obj->set_in_extra_data(true);
meta_obj->set_hash_source(mp_obj.get_key());
int ret;
std::unique_ptr<rgw::sal::Object::DeleteOp> del_op = meta_obj->get_delete_op();
del_op->params.bucket_owner = bucket->get_acl_owner();
del_op->params.versioning_status = 0;
// Since the data objects are associated with meta obj till
// MultipartUpload::Complete() is done, removing the metadata obj
// should remove all the uploads so far.
ret = del_op->delete_obj(dpp, null_yield);
if (ret < 0) {
ldpp_dout(dpp, 20) << __func__ << ": del_op.delete_obj returned " <<
ret << dendl;
}
return (ret == -ENOENT) ? -ERR_NO_SUCH_UPLOAD : ret;
}
static string mp_ns = RGW_OBJ_NS_MULTIPART;
std::unique_ptr<rgw::sal::Object> DBMultipartUpload::get_meta_obj()
{
return bucket->get_object(rgw_obj_key(get_meta(), string(), mp_ns));
}
int DBMultipartUpload::init(const DoutPrefixProvider *dpp, optional_yield y, ACLOwner& owner, rgw_placement_rule& dest_placement, rgw::sal::Attrs& attrs)
{
int ret;
std::string oid = mp_obj.get_key();
char buf[33];
std::unique_ptr<rgw::sal::Object> obj; // create meta obj
gen_rand_alphanumeric(store->ctx(), buf, sizeof(buf) - 1);
std::string upload_id = MULTIPART_UPLOAD_ID_PREFIX; /* v2 upload id */
upload_id.append(buf);
mp_obj.init(oid, upload_id);
obj = get_meta_obj();
DB::Object op_target(store->getDB(), obj->get_bucket()->get_info(),
obj->get_obj());
DB::Object::Write obj_op(&op_target);
/* Create meta object */
obj_op.meta.owner = owner.get_id();
obj_op.meta.category = RGWObjCategory::MultiMeta;
obj_op.meta.flags = PUT_OBJ_CREATE_EXCL;
obj_op.meta.mtime = &mtime;
multipart_upload_info upload_info;
upload_info.dest_placement = dest_placement;
bufferlist bl;
encode(upload_info, bl);
obj_op.meta.data = &bl;
ret = obj_op.prepare(dpp);
if (ret < 0)
return ret;
ret = obj_op.write_meta(dpp, bl.length(), bl.length(), attrs);
return ret;
}
int DBMultipartUpload::list_parts(const DoutPrefixProvider *dpp, CephContext *cct,
int num_parts, int marker,
int *next_marker, bool *truncated, optional_yield y,
bool assume_unsorted)
{
std::list<RGWUploadPartInfo> parts_map;
std::unique_ptr<rgw::sal::Object> obj = get_meta_obj();
parts.clear();
int ret;
DB::Object op_target(store->getDB(),
obj->get_bucket()->get_info(), obj->get_obj());
ret = op_target.get_mp_parts_list(dpp, parts_map);
if (ret < 0) {
return ret;
}
int last_num = 0;
while (!parts_map.empty()) {
std::unique_ptr<DBMultipartPart> part = std::make_unique<DBMultipartPart>();
RGWUploadPartInfo &pinfo = parts_map.front();
part->set_info(pinfo);
if ((int)pinfo.num > marker) {
last_num = pinfo.num;
parts[pinfo.num] = std::move(part);
}
parts_map.pop_front();
}
/* rebuild a map with only num_parts entries */
std::map<uint32_t, std::unique_ptr<MultipartPart>> new_parts;
std::map<uint32_t, std::unique_ptr<MultipartPart>>::iterator piter;
int i;
for (i = 0, piter = parts.begin();
i < num_parts && piter != parts.end();
++i, ++piter) {
last_num = piter->first;
new_parts[piter->first] = std::move(piter->second);
}
if (truncated) {
*truncated = (piter != parts.end());
}
parts.swap(new_parts);
if (next_marker) {
*next_marker = last_num;
}
return 0;
}
int DBMultipartUpload::complete(const DoutPrefixProvider *dpp,
optional_yield y, CephContext* cct,
map<int, string>& part_etags,
list<rgw_obj_index_key>& remove_objs,
uint64_t& accounted_size, bool& compressed,
RGWCompressionInfo& cs_info, off_t& ofs,
std::string& tag, ACLOwner& owner,
uint64_t olh_epoch,
rgw::sal::Object* target_obj)
{
char final_etag[CEPH_CRYPTO_MD5_DIGESTSIZE];
char final_etag_str[CEPH_CRYPTO_MD5_DIGESTSIZE * 2 + 16];
std::string etag;
bufferlist etag_bl;
MD5 hash;
bool truncated;
int ret;
int total_parts = 0;
int handled_parts = 0;
int max_parts = 1000;
int marker = 0;
uint64_t min_part_size = cct->_conf->rgw_multipart_min_part_size;
auto etags_iter = part_etags.begin();
rgw::sal::Attrs attrs = target_obj->get_attrs();
ofs = 0;
accounted_size = 0;
do {
ret = list_parts(dpp, cct, max_parts, marker, &marker, &truncated, y);
if (ret == -ENOENT) {
ret = -ERR_NO_SUCH_UPLOAD;
}
if (ret < 0)
return ret;
total_parts += parts.size();
if (!truncated && total_parts != (int)part_etags.size()) {
ldpp_dout(dpp, 0) << "NOTICE: total parts mismatch: have: " << total_parts
<< " expected: " << part_etags.size() << dendl;
ret = -ERR_INVALID_PART;
return ret;
}
for (auto obj_iter = parts.begin(); etags_iter != part_etags.end() && obj_iter != parts.end(); ++etags_iter, ++obj_iter, ++handled_parts) {
DBMultipartPart* part = dynamic_cast<rgw::sal::DBMultipartPart*>(obj_iter->second.get());
uint64_t part_size = part->get_size();
if (handled_parts < (int)part_etags.size() - 1 &&
part_size < min_part_size) {
ret = -ERR_TOO_SMALL;
return ret;
}
char petag[CEPH_CRYPTO_MD5_DIGESTSIZE];
if (etags_iter->first != (int)obj_iter->first) {
ldpp_dout(dpp, 0) << "NOTICE: parts num mismatch: next requested: "
<< etags_iter->first << " next uploaded: "
<< obj_iter->first << dendl;
ret = -ERR_INVALID_PART;
return ret;
}
string part_etag = rgw_string_unquote(etags_iter->second);
if (part_etag.compare(part->get_etag()) != 0) {
ldpp_dout(dpp, 0) << "NOTICE: etag mismatch: part: " << etags_iter->first
<< " etag: " << etags_iter->second << dendl;
ret = -ERR_INVALID_PART;
return ret;
}
hex_to_buf(part->get_etag().c_str(), petag,
CEPH_CRYPTO_MD5_DIGESTSIZE);
hash.Update((const unsigned char *)petag, sizeof(petag));
RGWUploadPartInfo& obj_part = part->get_info();
ofs += obj_part.size;
accounted_size += obj_part.accounted_size;
}
} while (truncated);
hash.Final((unsigned char *)final_etag);
buf_to_hex((unsigned char *)final_etag, sizeof(final_etag), final_etag_str);
snprintf(&final_etag_str[CEPH_CRYPTO_MD5_DIGESTSIZE * 2],
sizeof(final_etag_str) - CEPH_CRYPTO_MD5_DIGESTSIZE * 2,
"-%lld", (long long)part_etags.size());
etag = final_etag_str;
ldpp_dout(dpp, 10) << "calculated etag: " << etag << dendl;
etag_bl.append(etag);
attrs[RGW_ATTR_ETAG] = etag_bl;
/* XXX: handle compression ? */
/* Rename all the object data entries with original object name (i.e
* from 'head_obj.name + "." + upload_id' to head_obj.name) */
/* Original head object */
DB::Object op_target(store->getDB(),
target_obj->get_bucket()->get_info(),
target_obj->get_obj(), get_upload_id());
DB::Object::Write obj_op(&op_target);
ret = obj_op.prepare(dpp);
obj_op.meta.owner = owner.get_id();
obj_op.meta.flags = PUT_OBJ_CREATE;
obj_op.meta.category = RGWObjCategory::Main;
obj_op.meta.modify_tail = true;
obj_op.meta.completeMultipart = true;
ret = obj_op.write_meta(dpp, ofs, accounted_size, attrs);
if (ret < 0)
return ret;
/* No need to delete Meta obj here. It is deleted from sal */
return ret;
}
int DBMultipartUpload::get_info(const DoutPrefixProvider *dpp, optional_yield y, rgw_placement_rule** rule, rgw::sal::Attrs* attrs)
{
if (!rule && !attrs) {
return 0;
}
if (rule) {
if (!placement.empty()) {
*rule = &placement;
if (!attrs) {
/* Don't need attrs, done */
return 0;
}
} else {
*rule = nullptr;
}
}
/* We need either attributes or placement, so we need a read */
std::unique_ptr<rgw::sal::Object> meta_obj;
meta_obj = get_meta_obj();
meta_obj->set_in_extra_data(true);
multipart_upload_info upload_info;
bufferlist headbl;
/* Read the obj head which contains the multipart_upload_info */
std::unique_ptr<rgw::sal::Object::ReadOp> read_op = meta_obj->get_read_op();
int ret = read_op->prepare(y, dpp);
if (ret < 0) {
if (ret == -ENOENT) {
return -ERR_NO_SUCH_UPLOAD;
}
return ret;
}
if (attrs) {
/* Attrs are filled in by prepare */
*attrs = meta_obj->get_attrs();
if (!rule || *rule != nullptr) {
/* placement was cached; don't actually read */
return 0;
}
}
/* Now read the placement from the head */
ret = read_op->read(0, store->getDB()->get_max_head_size(), headbl, y, dpp);
if (ret < 0) {
if (ret == -ENOENT) {
return -ERR_NO_SUCH_UPLOAD;
}
return ret;
}
if (headbl.length() <= 0) {
return -ERR_NO_SUCH_UPLOAD;
}
/* Decode multipart_upload_info */
auto hiter = headbl.cbegin();
try {
decode(upload_info, hiter);
} catch (buffer::error& err) {
ldpp_dout(dpp, 0) << "ERROR: failed to decode multipart upload info" << dendl;
return -EIO;
}
placement = upload_info.dest_placement;
*rule = &placement;
return 0;
}
std::unique_ptr<Writer> DBMultipartUpload::get_writer(
const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num,
const std::string& part_num_str)
{
return std::make_unique<DBMultipartWriter>(dpp, y, this, obj, store, owner,
ptail_placement_rule, part_num, part_num_str);
}
DBMultipartWriter::DBMultipartWriter(const DoutPrefixProvider *dpp,
optional_yield y,
MultipartUpload* upload,
rgw::sal::Object* obj,
DBStore* _driver,
const rgw_user& _owner,
const rgw_placement_rule *_ptail_placement_rule,
uint64_t _part_num, const std::string& _part_num_str):
StoreWriter(dpp, y),
store(_driver),
owner(_owner),
ptail_placement_rule(_ptail_placement_rule),
head_obj(obj),
upload_id(upload->get_upload_id()),
part_num(_part_num),
oid(head_obj->get_name() + "." + upload_id +
"." + std::to_string(part_num)),
meta_obj(((DBMultipartUpload*)upload)->get_meta_obj()),
op_target(_driver->getDB(), head_obj->get_bucket()->get_info(), head_obj->get_obj(), upload_id),
parent_op(&op_target),
part_num_str(_part_num_str) {}
int DBMultipartWriter::prepare(optional_yield y)
{
parent_op.prepare(NULL);
parent_op.set_mp_part_str(upload_id + "." + std::to_string(part_num));
// XXX: do we need to handle part_num_str??
return 0;
}
int DBMultipartWriter::process(bufferlist&& data, uint64_t offset)
{
/* XXX: same as AtomicWriter..consolidate code */
total_data_size += data.length();
/* XXX: Optimize all bufferlist copies in this function */
/* copy head_data into meta. But for multipart we do not
* need to write head_data */
uint64_t max_chunk_size = store->getDB()->get_max_chunk_size();
int excess_size = 0;
/* Accumulate tail_data till max_chunk_size or flush op */
bufferlist tail_data;
if (data.length() != 0) {
parent_op.meta.data = &head_data; /* Null data ?? */
/* handle tail )parts.
* First accumulate and write data into dbstore in its chunk_size
* parts
*/
if (!tail_part_size) { /* new tail part */
tail_part_offset = offset;
}
data.begin(0).copy(data.length(), tail_data);
tail_part_size += tail_data.length();
tail_part_data.append(tail_data);
if (tail_part_size < max_chunk_size) {
return 0;
} else {
int write_ofs = 0;
while (tail_part_size >= max_chunk_size) {
excess_size = tail_part_size - max_chunk_size;
bufferlist tmp;
tail_part_data.begin(write_ofs).copy(max_chunk_size, tmp);
/* write tail objects data */
int ret = parent_op.write_data(dpp, tmp, tail_part_offset);
if (ret < 0) {
return ret;
}
tail_part_size -= max_chunk_size;
write_ofs += max_chunk_size;
tail_part_offset += max_chunk_size;
}
/* reset tail parts or update if excess data */
if (excess_size > 0) { /* wrote max_chunk_size data */
tail_part_size = excess_size;
bufferlist tmp;
tail_part_data.begin(write_ofs).copy(excess_size, tmp);
tail_part_data = tmp;
} else {
tail_part_size = 0;
tail_part_data.clear();
tail_part_offset = 0;
}
}
} else {
if (tail_part_size == 0) {
return 0; /* nothing more to write */
}
/* flush watever tail data is present */
int ret = parent_op.write_data(dpp, tail_part_data, tail_part_offset);
if (ret < 0) {
return ret;
}
tail_part_size = 0;
tail_part_data.clear();
tail_part_offset = 0;
}
return 0;
}
int DBMultipartWriter::complete(size_t accounted_size, const std::string& etag,
ceph::real_time *mtime, ceph::real_time set_mtime,
std::map<std::string, bufferlist>& attrs,
ceph::real_time delete_at,
const char *if_match, const char *if_nomatch,
const std::string *user_data,
rgw_zone_set *zones_trace, bool *canceled,
optional_yield y)
{
int ret = 0;
/* XXX: same as AtomicWriter..consolidate code */
parent_op.meta.mtime = mtime;
parent_op.meta.delete_at = delete_at;
parent_op.meta.if_match = if_match;
parent_op.meta.if_nomatch = if_nomatch;
parent_op.meta.user_data = user_data;
parent_op.meta.zones_trace = zones_trace;
/* XXX: handle accounted size */
accounted_size = total_data_size;
if (ret < 0)
return ret;
RGWUploadPartInfo info;
info.num = part_num;
info.etag = etag;
info.size = total_data_size;
info.accounted_size = accounted_size;
info.modified = real_clock::now();
//info.manifest = manifest;
DB::Object op_target(store->getDB(),
meta_obj->get_bucket()->get_info(), meta_obj->get_obj());
ret = op_target.add_mp_part(dpp, info);
if (ret < 0) {
return ret == -ENOENT ? -ERR_NO_SUCH_UPLOAD : ret;
}
return 0;
}
DBAtomicWriter::DBAtomicWriter(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* _obj,
DBStore* _driver,
const rgw_user& _owner,
const rgw_placement_rule *_ptail_placement_rule,
uint64_t _olh_epoch,
const std::string& _unique_tag) :
StoreWriter(dpp, y),
store(_driver),
owner(_owner),
ptail_placement_rule(_ptail_placement_rule),
olh_epoch(_olh_epoch),
unique_tag(_unique_tag),
obj(_driver, _obj->get_key(), _obj->get_bucket()),
op_target(_driver->getDB(), obj.get_bucket()->get_info(), obj.get_obj()),
parent_op(&op_target) {}
int DBAtomicWriter::prepare(optional_yield y)
{
return parent_op.prepare(NULL); /* send dpp */
}
int DBAtomicWriter::process(bufferlist&& data, uint64_t offset)
{
total_data_size += data.length();
/* XXX: Optimize all bufferlist copies in this function */
/* copy head_data into meta. */
uint64_t head_size = store->getDB()->get_max_head_size();
unsigned head_len = 0;
uint64_t max_chunk_size = store->getDB()->get_max_chunk_size();
int excess_size = 0;
/* Accumulate tail_data till max_chunk_size or flush op */
bufferlist tail_data;
if (data.length() != 0) {
if (offset < head_size) {
/* XXX: handle case (if exists) where offset > 0 & < head_size */
head_len = std::min((uint64_t)data.length(),
head_size - offset);
bufferlist tmp;
data.begin(0).copy(head_len, tmp);
head_data.append(tmp);
parent_op.meta.data = &head_data;
if (head_len == data.length()) {
return 0;
}
/* Move offset by copy_len */
offset = head_len;
}
/* handle tail parts.
* First accumulate and write data into dbstore in its chunk_size
* parts
*/
if (!tail_part_size) { /* new tail part */
tail_part_offset = offset;
}
data.begin(head_len).copy(data.length() - head_len, tail_data);
tail_part_size += tail_data.length();
tail_part_data.append(tail_data);
if (tail_part_size < max_chunk_size) {
return 0;
} else {
int write_ofs = 0;
while (tail_part_size >= max_chunk_size) {
excess_size = tail_part_size - max_chunk_size;
bufferlist tmp;
tail_part_data.begin(write_ofs).copy(max_chunk_size, tmp);
/* write tail objects data */
int ret = parent_op.write_data(dpp, tmp, tail_part_offset);
if (ret < 0) {
return ret;
}
tail_part_size -= max_chunk_size;
write_ofs += max_chunk_size;
tail_part_offset += max_chunk_size;
}
/* reset tail parts or update if excess data */
if (excess_size > 0) { /* wrote max_chunk_size data */
tail_part_size = excess_size;
bufferlist tmp;
tail_part_data.begin(write_ofs).copy(excess_size, tmp);
tail_part_data = tmp;
} else {
tail_part_size = 0;
tail_part_data.clear();
tail_part_offset = 0;
}
}
} else {
if (tail_part_size == 0) {
return 0; /* nothing more to write */
}
/* flush watever tail data is present */
int ret = parent_op.write_data(dpp, tail_part_data, tail_part_offset);
if (ret < 0) {
return ret;
}
tail_part_size = 0;
tail_part_data.clear();
tail_part_offset = 0;
}
return 0;
}
int DBAtomicWriter::complete(size_t accounted_size, const std::string& etag,
ceph::real_time *mtime, ceph::real_time set_mtime,
std::map<std::string, bufferlist>& attrs,
ceph::real_time delete_at,
const char *if_match, const char *if_nomatch,
const std::string *user_data,
rgw_zone_set *zones_trace, bool *canceled,
optional_yield y)
{
parent_op.meta.mtime = mtime;
parent_op.meta.delete_at = delete_at;
parent_op.meta.if_match = if_match;
parent_op.meta.if_nomatch = if_nomatch;
parent_op.meta.user_data = user_data;
parent_op.meta.zones_trace = zones_trace;
parent_op.meta.category = RGWObjCategory::Main;
/* XXX: handle accounted size */
accounted_size = total_data_size;
int ret = parent_op.write_meta(dpp, total_data_size, accounted_size, attrs);
if (canceled) {
*canceled = parent_op.meta.canceled;
}
return ret;
}
std::unique_ptr<RGWRole> DBStore::get_role(std::string name,
std::string tenant,
std::string path,
std::string trust_policy,
std::string max_session_duration_str,
std::multimap<std::string,std::string> tags)
{
RGWRole* p = nullptr;
return std::unique_ptr<RGWRole>(p);
}
std::unique_ptr<RGWRole> DBStore::get_role(std::string id)
{
RGWRole* p = nullptr;
return std::unique_ptr<RGWRole>(p);
}
std::unique_ptr<RGWRole> DBStore::get_role(const RGWRoleInfo& info)
{
RGWRole* p = nullptr;
return std::unique_ptr<RGWRole>(p);
}
int DBStore::get_roles(const DoutPrefixProvider *dpp,
optional_yield y,
const std::string& path_prefix,
const std::string& tenant,
vector<std::unique_ptr<RGWRole>>& roles)
{
return 0;
}
std::unique_ptr<RGWOIDCProvider> DBStore::get_oidc_provider()
{
RGWOIDCProvider* p = nullptr;
return std::unique_ptr<RGWOIDCProvider>(p);
}
int DBStore::get_oidc_providers(const DoutPrefixProvider *dpp,
const std::string& tenant,
vector<std::unique_ptr<RGWOIDCProvider>>& providers, optional_yield y)
{
return 0;
}
std::unique_ptr<Writer> DBStore::get_append_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
const std::string& unique_tag,
uint64_t position,
uint64_t *cur_accounted_size) {
return nullptr;
}
std::unique_ptr<Writer> DBStore::get_atomic_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag) {
return std::make_unique<DBAtomicWriter>(dpp, y, obj, this, owner,
ptail_placement_rule, olh_epoch, unique_tag);
}
const std::string& DBStore::get_compression_type(const rgw_placement_rule& rule) {
return zone.get_rgw_params().get_compression_type(rule);
}
bool DBStore::valid_placement(const rgw_placement_rule& rule)
{
// XXX: Till zonegroup, zone and storage-classes can be configured
// for dbstore return true
return true; //zone.get_rgw_params().valid_placement(rule);
}
std::unique_ptr<User> DBStore::get_user(const rgw_user &u)
{
return std::make_unique<DBUser>(this, u);
}
int DBStore::get_user_by_access_key(const DoutPrefixProvider *dpp, const std::string& key, optional_yield y, std::unique_ptr<User>* user)
{
RGWUserInfo uinfo;
User *u;
int ret = 0;
RGWObjVersionTracker objv_tracker;
ret = getDB()->get_user(dpp, string("access_key"), key, uinfo, nullptr,
&objv_tracker);
if (ret < 0)
return ret;
u = new DBUser(this, uinfo);
if (!u)
return -ENOMEM;
u->get_version_tracker() = objv_tracker;
user->reset(u);
return 0;
}
int DBStore::get_user_by_email(const DoutPrefixProvider *dpp, const std::string& email, optional_yield y, std::unique_ptr<User>* user)
{
RGWUserInfo uinfo;
User *u;
int ret = 0;
RGWObjVersionTracker objv_tracker;
ret = getDB()->get_user(dpp, string("email"), email, uinfo, nullptr,
&objv_tracker);
if (ret < 0)
return ret;
u = new DBUser(this, uinfo);
if (!u)
return -ENOMEM;
u->get_version_tracker() = objv_tracker;
user->reset(u);
return ret;
}
int DBStore::get_user_by_swift(const DoutPrefixProvider *dpp, const std::string& user_str, optional_yield y, std::unique_ptr<User>* user)
{
/* Swift keys and subusers are not supported for now */
return -ENOTSUP;
}
std::string DBStore::get_cluster_id(const DoutPrefixProvider* dpp, optional_yield y)
{
return "PLACEHOLDER"; // for instance unique identifier
}
std::unique_ptr<Object> DBStore::get_object(const rgw_obj_key& k)
{
return std::make_unique<DBObject>(this, k);
}
int DBStore::get_bucket(const DoutPrefixProvider *dpp, User* u, const rgw_bucket& b, std::unique_ptr<Bucket>* bucket, optional_yield y)
{
int ret;
Bucket* bp;
bp = new DBBucket(this, b, u);
ret = bp->load_bucket(dpp, y);
if (ret < 0) {
delete bp;
return ret;
}
bucket->reset(bp);
return 0;
}
int DBStore::get_bucket(User* u, const RGWBucketInfo& i, std::unique_ptr<Bucket>* bucket)
{
Bucket* bp;
bp = new DBBucket(this, i, u);
/* Don't need to fetch the bucket info, use the provided one */
bucket->reset(bp);
return 0;
}
int DBStore::get_bucket(const DoutPrefixProvider *dpp, User* u, const std::string& tenant, const std::string& name, std::unique_ptr<Bucket>* bucket, optional_yield y)
{
rgw_bucket b;
b.tenant = tenant;
b.name = name;
return get_bucket(dpp, u, b, bucket, y);
}
bool DBStore::is_meta_master()
{
return true;
}
int DBStore::forward_request_to_master(const DoutPrefixProvider *dpp, User* user, obj_version *objv,
bufferlist& in_data,
JSONParser *jp, req_info& info,
optional_yield y)
{
return 0;
}
int DBStore::forward_iam_request_to_master(const DoutPrefixProvider *dpp, const RGWAccessKey& key, obj_version* objv,
bufferlist& in_data,
RGWXMLDecoder::XMLParser* parser, req_info& info,
optional_yield y)
{
return 0;
}
std::string DBStore::zone_unique_id(uint64_t unique_num)
{
return "";
}
std::string DBStore::zone_unique_trans_id(const uint64_t unique_num)
{
return "";
}
int DBStore::get_zonegroup(const std::string& id, std::unique_ptr<ZoneGroup>* zg)
{
/* XXX: for now only one zonegroup supported */
ZoneGroup* group = new DBZoneGroup(this, std::make_unique<RGWZoneGroup>());
if (!group)
return -ENOMEM;
zg->reset(group);
return 0;
}
int DBStore::list_all_zones(const DoutPrefixProvider* dpp,
std::list<std::string>& zone_ids)
{
zone_ids.push_back(zone.get_id());
return 0;
}
int DBStore::cluster_stat(RGWClusterStat& stats)
{
return 0;
}
std::unique_ptr<Lifecycle> DBStore::get_lifecycle(void)
{
return std::make_unique<DBLifecycle>(this);
}
int DBLifecycle::get_entry(const std::string& oid, const std::string& marker,
std::unique_ptr<LCEntry>* entry)
{
return store->getDB()->get_entry(oid, marker, entry);
}
int DBLifecycle::get_next_entry(const std::string& oid, const std::string& marker,
std::unique_ptr<LCEntry>* entry)
{
return store->getDB()->get_next_entry(oid, marker, entry);
}
int DBLifecycle::set_entry(const std::string& oid, LCEntry& entry)
{
return store->getDB()->set_entry(oid, entry);
}
int DBLifecycle::list_entries(const std::string& oid, const std::string& marker,
uint32_t max_entries, vector<std::unique_ptr<LCEntry>>& entries)
{
return store->getDB()->list_entries(oid, marker, max_entries, entries);
}
int DBLifecycle::rm_entry(const std::string& oid, LCEntry& entry)
{
return store->getDB()->rm_entry(oid, entry);
}
int DBLifecycle::get_head(const std::string& oid, std::unique_ptr<LCHead>* head)
{
return store->getDB()->get_head(oid, head);
}
int DBLifecycle::put_head(const std::string& oid, LCHead& head)
{
return store->getDB()->put_head(oid, head);
}
std::unique_ptr<LCSerializer> DBLifecycle::get_serializer(const std::string& lock_name,
const std::string& oid,
const std::string& cookie)
{
return std::make_unique<LCDBSerializer>(store, oid, lock_name, cookie);
}
std::unique_ptr<Notification> DBStore::get_notification(
rgw::sal::Object* obj, rgw::sal::Object* src_obj, req_state* s,
rgw::notify::EventType event_type, optional_yield y,
const std::string* object_name)
{
return std::make_unique<DBNotification>(obj, src_obj, event_type);
}
std::unique_ptr<Notification> DBStore::get_notification(
const DoutPrefixProvider* dpp, rgw::sal::Object* obj,
rgw::sal::Object* src_obj,
rgw::notify::EventType event_type, rgw::sal::Bucket* _bucket,
std::string& _user_id, std::string& _user_tenant, std::string& _req_id,
optional_yield y)
{
return std::make_unique<DBNotification>(obj, src_obj, event_type);
}
RGWLC* DBStore::get_rgwlc(void) {
return lc;
}
int DBStore::log_usage(const DoutPrefixProvider *dpp, map<rgw_user_bucket, RGWUsageBatch>& usage_info, optional_yield y)
{
return 0;
}
int DBStore::log_op(const DoutPrefixProvider *dpp, string& oid, bufferlist& bl)
{
return 0;
}
int DBStore::register_to_service_map(const DoutPrefixProvider *dpp, const string& daemon_type,
const map<string, string>& meta)
{
return 0;
}
void DBStore::get_ratelimit(RGWRateLimitInfo& bucket_ratelimit, RGWRateLimitInfo& user_ratelimit, RGWRateLimitInfo& anon_ratelimit)
{
return;
}
void DBStore::get_quota(RGWQuota& quota)
{
// XXX: Not handled for the first pass
return;
}
int DBStore::set_buckets_enabled(const DoutPrefixProvider *dpp, vector<rgw_bucket>& buckets, bool enabled, optional_yield y)
{
int ret = 0;
vector<rgw_bucket>::iterator iter;
for (iter = buckets.begin(); iter != buckets.end(); ++iter) {
rgw_bucket& bucket = *iter;
if (enabled) {
ldpp_dout(dpp, 20) << "enabling bucket name=" << bucket.name << dendl;
} else {
ldpp_dout(dpp, 20) << "disabling bucket name=" << bucket.name << dendl;
}
RGWBucketInfo info;
map<string, bufferlist> attrs;
int r = getDB()->get_bucket_info(dpp, string("name"), "", info, &attrs,
nullptr, nullptr);
if (r < 0) {
ldpp_dout(dpp, 0) << "NOTICE: get_bucket_info on bucket=" << bucket.name << " returned err=" << r << ", skipping bucket" << dendl;
ret = r;
continue;
}
if (enabled) {
info.flags &= ~BUCKET_SUSPENDED;
} else {
info.flags |= BUCKET_SUSPENDED;
}
r = getDB()->update_bucket(dpp, "info", info, false, nullptr, &attrs, nullptr, &info.objv_tracker);
if (r < 0) {
ldpp_dout(dpp, 0) << "NOTICE: put_bucket_info on bucket=" << bucket.name << " returned err=" << r << ", skipping bucket" << dendl;
ret = r;
continue;
}
}
return ret;
}
int DBStore::get_sync_policy_handler(const DoutPrefixProvider *dpp,
std::optional<rgw_zone_id> zone,
std::optional<rgw_bucket> bucket,
RGWBucketSyncPolicyHandlerRef *phandler,
optional_yield y)
{
return 0;
}
RGWDataSyncStatusManager* DBStore::get_data_sync_manager(const rgw_zone_id& source_zone)
{
return 0;
}
int DBStore::read_all_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch,
uint32_t max_entries, bool *is_truncated,
RGWUsageIter& usage_iter,
map<rgw_user_bucket, rgw_usage_log_entry>& usage)
{
return 0;
}
int DBStore::trim_all_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch, optional_yield y)
{
return 0;
}
int DBStore::get_config_key_val(string name, bufferlist *bl)
{
return -ENOTSUP;
}
int DBStore::meta_list_keys_init(const DoutPrefixProvider *dpp, const string& section, const string& marker, void** phandle)
{
return 0;
}
int DBStore::meta_list_keys_next(const DoutPrefixProvider *dpp, void* handle, int max, list<string>& keys, bool* truncated)
{
return 0;
}
void DBStore::meta_list_keys_complete(void* handle)
{
return;
}
std::string DBStore::meta_get_marker(void* handle)
{
return "";
}
int DBStore::meta_remove(const DoutPrefixProvider *dpp, string& metadata_key, optional_yield y)
{
return 0;
}
int DBStore::initialize(CephContext *_cct, const DoutPrefixProvider *_dpp) {
int ret = 0;
cct = _cct;
dpp = _dpp;
lc = new RGWLC();
lc->initialize(cct, this);
if (use_lc_thread) {
ret = db->createLCTables(dpp);
lc->start_processor();
}
ret = db->createGC(dpp);
if (ret < 0) {
ldpp_dout(dpp, 0) <<"GC thread creation failed: ret = " << ret << dendl;
}
return ret;
}
int DBLuaManager::get_script(const DoutPrefixProvider* dpp, optional_yield y, const std::string& key, std::string& script)
{
return -ENOENT;
}
int DBLuaManager::put_script(const DoutPrefixProvider* dpp, optional_yield y, const std::string& key, const std::string& script)
{
return -ENOENT;
}
int DBLuaManager::del_script(const DoutPrefixProvider* dpp, optional_yield y, const std::string& key)
{
return -ENOENT;
}
int DBLuaManager::add_package(const DoutPrefixProvider* dpp, optional_yield y, const std::string& package_name)
{
return -ENOENT;
}
int DBLuaManager::remove_package(const DoutPrefixProvider* dpp, optional_yield y, const std::string& package_name)
{
return -ENOENT;
}
int DBLuaManager::list_packages(const DoutPrefixProvider* dpp, optional_yield y, rgw::lua::packages_t& packages)
{
return -ENOENT;
}
} // namespace rgw::sal
extern "C" {
void *newDBStore(CephContext *cct)
{
rgw::sal::DBStore *driver = new rgw::sal::DBStore();
DBStoreManager *dbsm = new DBStoreManager(cct);
DB *db = dbsm->getDB();
if (!db) {
delete dbsm;
delete driver;
return nullptr;
}
driver->setDBStoreManager(dbsm);
driver->setDB(db);
db->set_driver((rgw::sal::Driver*)driver);
db->set_context(cct);
return driver;
}
}
| 58,908 | 28.191774 | 178 |
cc
|
null |
ceph-main/src/rgw/rgw_sal_dbstore.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2021 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#pragma once
#include "rgw_sal_store.h"
#include "rgw_oidc_provider.h"
#include "rgw_role.h"
#include "rgw_lc.h"
#include "rgw_multi.h"
#include "driver/dbstore/common/dbstore.h"
#include "driver/dbstore/dbstore_mgr.h"
namespace rgw { namespace sal {
class DBStore;
class LCDBSerializer : public StoreLCSerializer {
public:
LCDBSerializer(DBStore* store, const std::string& oid, const std::string& lock_name, const std::string& cookie) {}
virtual int try_lock(const DoutPrefixProvider *dpp, utime_t dur, optional_yield y) override { return 0; }
virtual int unlock() override {
return 0;
}
};
class DBLifecycle : public StoreLifecycle {
DBStore* store;
public:
DBLifecycle(DBStore* _st) : store(_st) {}
using StoreLifecycle::get_entry;
virtual int get_entry(const std::string& oid, const std::string& marker, std::unique_ptr<LCEntry>* entry) override;
virtual int get_next_entry(const std::string& oid, const std::string& marker, std::unique_ptr<LCEntry>* entry) override;
virtual int set_entry(const std::string& oid, LCEntry& entry) override;
virtual int list_entries(const std::string& oid, const std::string& marker,
uint32_t max_entries,
std::vector<std::unique_ptr<LCEntry>>& entries) override;
virtual int rm_entry(const std::string& oid, LCEntry& entry) override;
virtual int get_head(const std::string& oid, std::unique_ptr<LCHead>* head) override;
virtual int put_head(const std::string& oid, LCHead& head) override;
virtual std::unique_ptr<LCSerializer> get_serializer(const std::string& lock_name,
const std::string& oid,
const std::string& cookie) override;
};
class DBNotification : public StoreNotification {
protected:
public:
DBNotification(Object* _obj, Object* _src_obj, rgw::notify::EventType _type)
: StoreNotification(_obj, _src_obj, _type) {}
~DBNotification() = default;
virtual int publish_reserve(const DoutPrefixProvider *dpp, RGWObjTags* obj_tags = nullptr) override { return 0;}
virtual int publish_commit(const DoutPrefixProvider* dpp, uint64_t size,
const ceph::real_time& mtime, const std::string& etag, const std::string& version) override { return 0; }
};
class DBUser : public StoreUser {
private:
DBStore *store;
public:
DBUser(DBStore *_st, const rgw_user& _u) : StoreUser(_u), store(_st) { }
DBUser(DBStore *_st, const RGWUserInfo& _i) : StoreUser(_i), store(_st) { }
DBUser(DBStore *_st) : store(_st) { }
DBUser(DBUser& _o) = default;
DBUser() {}
virtual std::unique_ptr<User> clone() override {
return std::unique_ptr<User>(new DBUser(*this));
}
int list_buckets(const DoutPrefixProvider *dpp, const std::string& marker, const std::string& end_marker,
uint64_t max, bool need_stats, BucketList& buckets, optional_yield y) override;
virtual int create_bucket(const DoutPrefixProvider* dpp,
const rgw_bucket& b,
const std::string& zonegroup_id,
rgw_placement_rule& placement_rule,
std::string& swift_ver_location,
const RGWQuotaInfo* pquota_info,
const RGWAccessControlPolicy& policy,
Attrs& attrs,
RGWBucketInfo& info,
obj_version& ep_objv,
bool exclusive,
bool obj_lock_enabled,
bool* existed,
req_info& req_info,
std::unique_ptr<Bucket>* bucket,
optional_yield y) override;
virtual int read_attrs(const DoutPrefixProvider* dpp, optional_yield y) override;
virtual int read_stats(const DoutPrefixProvider *dpp,
optional_yield y, RGWStorageStats* stats,
ceph::real_time *last_stats_sync = nullptr,
ceph::real_time *last_stats_update = nullptr) override;
virtual int read_stats_async(const DoutPrefixProvider *dpp, RGWGetUserStats_CB* cb) override;
virtual int complete_flush_stats(const DoutPrefixProvider *dpp, optional_yield y) override;
virtual int read_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch, uint32_t max_entries,
bool* is_truncated, RGWUsageIter& usage_iter,
std::map<rgw_user_bucket, rgw_usage_log_entry>& usage) override;
virtual int trim_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch, optional_yield y) override;
/* Placeholders */
virtual int merge_and_store_attrs(const DoutPrefixProvider* dpp, Attrs& new_attrs, optional_yield y) override;
virtual int load_user(const DoutPrefixProvider* dpp, optional_yield y) override;
virtual int store_user(const DoutPrefixProvider* dpp, optional_yield y, bool exclusive, RGWUserInfo* old_info = nullptr) override;
virtual int remove_user(const DoutPrefixProvider* dpp, optional_yield y) override;
virtual int verify_mfa(const std::string& mfa_str, bool* verified, const DoutPrefixProvider* dpp, optional_yield y) override;
friend class DBBucket;
};
class DBBucket : public StoreBucket {
private:
DBStore *store;
RGWAccessControlPolicy acls;
public:
DBBucket(DBStore *_st)
: store(_st),
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 RGWBucketEnt& _e)
: StoreBucket(_e),
store(_st),
acls() {
}
DBBucket(DBStore *_st, const RGWBucketInfo& _i)
: StoreBucket(_i),
store(_st),
acls() {
}
DBBucket(DBStore *_st, const rgw_bucket& _b, User* _u)
: StoreBucket(_b, _u),
store(_st),
acls() {
}
DBBucket(DBStore *_st, const RGWBucketEnt& _e, User* _u)
: StoreBucket(_e, _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;
virtual int list(const DoutPrefixProvider *dpp, ListParams&, int, ListResults&, optional_yield y) override;
virtual int remove_bucket(const DoutPrefixProvider *dpp, bool delete_children, bool forward_to_master, req_info* req_info, optional_yield y) override;
virtual int remove_bucket_bypass_gc(int concurrent_max, bool
keep_index_consistent,
optional_yield y, const
DoutPrefixProvider *dpp) override;
virtual RGWAccessControlPolicy& get_acl(void) override { return acls; }
virtual int set_acl(const DoutPrefixProvider *dpp, RGWAccessControlPolicy& acl, optional_yield y) override;
virtual int load_bucket(const DoutPrefixProvider *dpp, optional_yield y, bool get_stats = false) override;
virtual int read_stats(const DoutPrefixProvider *dpp,
const bucket_index_layout_generation& idx_layout,
int shard_id,
std::string *bucket_ver, std::string *master_ver,
std::map<RGWObjCategory, RGWStorageStats>& stats,
std::string *max_marker = nullptr,
bool *syncstopped = nullptr) override;
virtual int read_stats_async(const DoutPrefixProvider *dpp, const bucket_index_layout_generation& idx_layout, int shard_id, RGWGetBucketStats_CB* ctx) override;
virtual int sync_user_stats(const DoutPrefixProvider *dpp, optional_yield y) override;
virtual int update_container_stats(const DoutPrefixProvider *dpp, optional_yield y) override;
virtual int check_bucket_shards(const DoutPrefixProvider *dpp, optional_yield y) override;
virtual int chown(const DoutPrefixProvider *dpp, User& new_user, 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 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 merge_and_store_attrs(const DoutPrefixProvider *dpp, Attrs& attrs, optional_yield y) override;
virtual int try_refresh_info(const DoutPrefixProvider *dpp, ceph::real_time *pmtime, optional_yield y) override;
virtual int read_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch, uint32_t max_entries,
bool *is_truncated, RGWUsageIter& usage_iter,
std::map<rgw_user_bucket, rgw_usage_log_entry>& usage) override;
virtual int trim_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch, optional_yield y) override;
virtual int remove_objs_from_index(const DoutPrefixProvider *dpp, std::list<rgw_obj_index_key>& objs_to_unlink) override;
virtual int check_index(const DoutPrefixProvider *dpp, std::map<RGWObjCategory, RGWStorageStats>& existing_stats, std::map<RGWObjCategory, RGWStorageStats>& calculated_stats) override;
virtual int rebuild_index(const DoutPrefixProvider *dpp) override;
virtual int set_tag_timeout(const DoutPrefixProvider *dpp, uint64_t timeout) override;
virtual int purge_instance(const DoutPrefixProvider *dpp, optional_yield y) override;
virtual std::unique_ptr<Bucket> clone() override {
return std::make_unique<DBBucket>(*this);
}
virtual std::unique_ptr<MultipartUpload> get_multipart_upload(
const std::string& oid, std::optional<std::string> upload_id,
ACLOwner owner={}, ceph::real_time mtime=ceph::real_clock::now()) override;
virtual int list_multiparts(const DoutPrefixProvider *dpp,
const std::string& prefix,
std::string& marker,
const std::string& delim,
const int& max_uploads,
std::vector<std::unique_ptr<MultipartUpload>>& uploads,
std::map<std::string, bool> *common_prefixes,
bool *is_truncated, optional_yield y) override;
virtual int abort_multiparts(const DoutPrefixProvider* dpp,
CephContext* cct, optional_yield y) override;
friend class DBStore;
};
class DBPlacementTier: public StorePlacementTier {
DBStore* store;
RGWZoneGroupPlacementTier tier;
public:
DBPlacementTier(DBStore* _store, const RGWZoneGroupPlacementTier& _tier) : store(_store), tier(_tier) {}
virtual ~DBPlacementTier() = default;
virtual const std::string& get_tier_type() { return tier.tier_type; }
virtual const std::string& get_storage_class() { return tier.storage_class; }
virtual bool retain_head_object() { return tier.retain_head_object; }
RGWZoneGroupPlacementTier& get_rt() { return tier; }
};
class DBZoneGroup : public StoreZoneGroup {
DBStore* store;
std::unique_ptr<RGWZoneGroup> group;
std::string empty;
public:
DBZoneGroup(DBStore* _store, std::unique_ptr<RGWZoneGroup> _group) : store(_store), group(std::move(_group)) {}
virtual ~DBZoneGroup() = default;
virtual const std::string& get_id() const override { return group->get_id(); };
virtual const std::string& get_name() const override { return group->get_name(); };
virtual int equals(const std::string& other_zonegroup) const override {
return group->equals(other_zonegroup);
};
/** Get the endpoint from zonegroup, or from master zone if not set */
virtual const std::string& get_endpoint() const override;
virtual bool placement_target_exists(std::string& target) const override;
virtual bool is_master_zonegroup() const override {
return group->is_master_zonegroup();
};
virtual const std::string& get_api_name() const override { return group->api_name; };
virtual int get_placement_target_names(std::set<std::string>& names) const override;
virtual const std::string& get_default_placement_name() const override {
return group->default_placement.name; };
virtual int get_hostnames(std::list<std::string>& names) const override {
names = group->hostnames;
return 0;
};
virtual int get_s3website_hostnames(std::list<std::string>& names) const override {
names = group->hostnames_s3website;
return 0;
};
virtual int get_zone_count() const override {
/* currently only 1 zone supported */
return 1;
}
virtual int get_placement_tier(const rgw_placement_rule& rule,
std::unique_ptr<PlacementTier>* tier) {
return -1;
}
virtual int get_zone_by_id(const std::string& id, std::unique_ptr<Zone>* zone) override {
return -1;
}
virtual int get_zone_by_name(const std::string& name, std::unique_ptr<Zone>* zone) override {
return -1;
}
virtual int list_zones(std::list<std::string>& zone_ids) override {
zone_ids.clear();
return 0;
}
virtual std::unique_ptr<ZoneGroup> clone() override {
std::unique_ptr<RGWZoneGroup>zg = std::make_unique<RGWZoneGroup>(*group.get());
return std::make_unique<DBZoneGroup>(store, std::move(zg));
}
};
class DBZone : public StoreZone {
protected:
DBStore* store;
RGWRealm *realm{nullptr};
DBZoneGroup *zonegroup{nullptr};
RGWZone *zone_public_config{nullptr}; /* external zone params, e.g., entrypoints, log flags, etc. */
RGWZoneParams *zone_params{nullptr}; /* internal zone params, e.g., rados pools */
RGWPeriod *current_period{nullptr};
public:
DBZone(DBStore* _store) : store(_store) {
realm = new RGWRealm();
zonegroup = new DBZoneGroup(store, std::make_unique<RGWZoneGroup>());
zone_public_config = new RGWZone();
zone_params = new RGWZoneParams();
current_period = new RGWPeriod();
// XXX: only default and STANDARD supported for now
RGWZonePlacementInfo info;
RGWZoneStorageClasses sc;
sc.set_storage_class("STANDARD", nullptr, nullptr);
info.storage_classes = sc;
zone_params->placement_pools["default"] = info;
}
~DBZone() {
delete realm;
delete zonegroup;
delete zone_public_config;
delete zone_params;
delete current_period;
}
virtual std::unique_ptr<Zone> clone() override {
return std::make_unique<DBZone>(store);
}
virtual ZoneGroup& get_zonegroup() override;
const RGWZoneParams& get_rgw_params();
virtual const std::string& get_id() override;
virtual const std::string& get_name() const override;
virtual bool is_writeable() override;
virtual bool get_redirect_endpoint(std::string* endpoint) override;
virtual bool has_zonegroup_api(const std::string& api) const override;
virtual const std::string& get_current_period_id() override;
virtual const RGWAccessKey& get_system_key() override;
virtual const std::string& get_realm_name() override;
virtual const std::string& get_realm_id() override;
virtual const std::string_view get_tier_type() override { return "rgw"; }
virtual RGWBucketSyncPolicyHandlerRef get_sync_policy_handler() override;
};
class DBLuaManager : public StoreLuaManager {
DBStore* store;
public:
DBLuaManager(DBStore* _s) : store(_s)
{
}
virtual ~DBLuaManager() = default;
/** Get a script named with the given key from the backing store */
virtual int get_script(const DoutPrefixProvider* dpp, optional_yield y, const std::string& key, std::string& script) override;
/** Put a script named with the given key to the backing store */
virtual int put_script(const DoutPrefixProvider* dpp, optional_yield y, const std::string& key, const std::string& script) override;
/** Delete a script named with the given key from the backing store */
virtual int del_script(const DoutPrefixProvider* dpp, optional_yield y, const std::string& key) override;
/** Add a lua package */
virtual int add_package(const DoutPrefixProvider* dpp, optional_yield y, const std::string& package_name) override;
/** Remove a lua package */
virtual int remove_package(const DoutPrefixProvider* dpp, optional_yield y, const std::string& package_name) override;
/** List lua packages */
virtual int list_packages(const DoutPrefixProvider* dpp, optional_yield y, rgw::lua::packages_t& packages) override;
};
class DBOIDCProvider : public RGWOIDCProvider {
DBStore* store;
public:
DBOIDCProvider(DBStore* _store) : store(_store) {}
~DBOIDCProvider() = default;
virtual int store_url(const DoutPrefixProvider *dpp, const std::string& url, bool exclusive, optional_yield y) override { return 0; }
virtual int read_url(const DoutPrefixProvider *dpp, const std::string& url, const std::string& tenant, optional_yield y) override { return 0; }
virtual int delete_obj(const DoutPrefixProvider *dpp, optional_yield y) override { return 0;}
void encode(bufferlist& bl) const {
RGWOIDCProvider::encode(bl);
}
void decode(bufferlist::const_iterator& bl) {
RGWOIDCProvider::decode(bl);
}
};
/*
* For multipart upload, below is the process flow -
*
* MultipartUpload::Init - create head object of meta obj (src_obj_name + "." + upload_id)
* [ Meta object stores all the parts upload info]
* MultipartWriter::process - create all data/tail objects with obj_name same as
* meta obj (so that they can all be identified & deleted
* during abort)
* MultipartUpload::Abort - Just delete meta obj .. that will indirectly delete all the
* uploads associated with that upload id / meta obj so far.
* MultipartUpload::Complete - create head object of the original object (if not exists) &
* rename all data/tail objects to orig object name and update
* metadata of the orig object.
*/
class DBMultipartPart : public StoreMultipartPart {
protected:
RGWUploadPartInfo info; /* XXX: info contains manifest also which is not needed */
public:
DBMultipartPart() = default;
virtual ~DBMultipartPart() = default;
virtual RGWUploadPartInfo& get_info() { return info; }
virtual void set_info(const RGWUploadPartInfo& _info) { info = _info; }
virtual uint32_t get_num() { return info.num; }
virtual uint64_t get_size() { return info.accounted_size; }
virtual const std::string& get_etag() { return info.etag; }
virtual ceph::real_time& get_mtime() { return info.modified; }
};
class DBMPObj {
std::string oid; // object name
std::string upload_id;
std::string meta; // multipart meta object = <oid>.<upload_id>
public:
DBMPObj() {}
DBMPObj(const std::string& _oid, const std::string& _upload_id) {
init(_oid, _upload_id, _upload_id);
}
DBMPObj(const std::string& _oid, std::optional<std::string> _upload_id) {
if (_upload_id) {
init(_oid, *_upload_id, *_upload_id);
} else {
from_meta(_oid);
}
}
void init(const std::string& _oid, const std::string& _upload_id) {
init(_oid, _upload_id, _upload_id);
}
void init(const std::string& _oid, const std::string& _upload_id, const std::string& part_unique_str) {
if (_oid.empty()) {
clear();
return;
}
oid = _oid;
upload_id = _upload_id;
meta = oid + "." + upload_id;
}
const std::string& get_upload_id() const {
return upload_id;
}
const std::string& get_key() const {
return oid;
}
const std::string& get_meta() const { return meta; }
bool from_meta(const std::string& meta) {
int end_pos = meta.length();
int mid_pos = meta.rfind('.', end_pos - 1); // <key>.<upload_id>
if (mid_pos < 0)
return false;
oid = meta.substr(0, mid_pos);
upload_id = meta.substr(mid_pos + 1, end_pos - mid_pos - 1);
init(oid, upload_id, upload_id);
return true;
}
void clear() {
oid = "";
meta = "";
upload_id = "";
}
};
class DBMultipartUpload : public StoreMultipartUpload {
DBStore* store;
DBMPObj mp_obj;
ACLOwner owner;
ceph::real_time mtime;
rgw_placement_rule placement;
public:
DBMultipartUpload(DBStore* _store, Bucket* _bucket, const std::string& oid, std::optional<std::string> upload_id, ACLOwner _owner, ceph::real_time _mtime) : StoreMultipartUpload(_bucket), store(_store), mp_obj(oid, upload_id), owner(_owner), mtime(_mtime) {}
virtual ~DBMultipartUpload() = default;
virtual const std::string& get_meta() const { return mp_obj.get_meta(); }
virtual const std::string& get_key() const { return mp_obj.get_key(); }
virtual const std::string& get_upload_id() const { return mp_obj.get_upload_id(); }
virtual const ACLOwner& get_owner() const override { return owner; }
virtual ceph::real_time& get_mtime() { return mtime; }
virtual std::unique_ptr<rgw::sal::Object> get_meta_obj() override;
virtual int init(const DoutPrefixProvider* dpp, optional_yield y, ACLOwner& owner, rgw_placement_rule& dest_placement, rgw::sal::Attrs& attrs) override;
virtual int list_parts(const DoutPrefixProvider* dpp, CephContext* cct,
int num_parts, int marker,
int* next_marker, bool* truncated, optional_yield y,
bool assume_unsorted = false) override;
virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct, optional_yield y) override;
virtual int complete(const DoutPrefixProvider* dpp,
optional_yield y, CephContext* cct,
std::map<int, std::string>& part_etags,
std::list<rgw_obj_index_key>& remove_objs,
uint64_t& accounted_size, bool& compressed,
RGWCompressionInfo& cs_info, off_t& ofs,
std::string& tag, ACLOwner& owner,
uint64_t olh_epoch,
rgw::sal::Object* target_obj) override;
virtual int get_info(const DoutPrefixProvider *dpp, optional_yield y, rgw_placement_rule** rule, 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,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num,
const std::string& part_num_str) override;
};
class DBObject : public StoreObject {
private:
DBStore* store;
RGWAccessControlPolicy acls;
public:
struct DBReadOp : public ReadOp {
private:
DBObject* source;
RGWObjectCtx* rctx;
DB::Object op_target;
DB::Object::Read parent_op;
public:
DBReadOp(DBObject *_source, RGWObjectCtx *_rctx);
virtual int prepare(optional_yield y, const DoutPrefixProvider* dpp) override;
/*
* Both `read` and `iterate` read up through index `end`
* *inclusive*. The number of bytes that could be returned is
* `end - ofs + 1`.
*/
virtual int read(int64_t ofs, int64_t end, bufferlist& bl,
optional_yield y,
const DoutPrefixProvider* dpp) override;
virtual int iterate(const DoutPrefixProvider* dpp, int64_t ofs,
int64_t end, RGWGetDataCB* cb,
optional_yield y) override;
virtual int get_attr(const DoutPrefixProvider* dpp, const char* name, bufferlist& dest, optional_yield y) override;
};
struct DBDeleteOp : public DeleteOp {
private:
DBObject* source;
DB::Object op_target;
DB::Object::Delete parent_op;
public:
DBDeleteOp(DBObject* _source);
virtual int delete_obj(const DoutPrefixProvider* dpp, optional_yield y) override;
};
DBObject() = default;
DBObject(DBStore *_st, const rgw_obj_key& _k)
: StoreObject(_k),
store(_st),
acls() {}
DBObject(DBStore *_st, const rgw_obj_key& _k, Bucket* _b)
: StoreObject(_k, _b),
store(_st),
acls() {}
DBObject(DBObject& _o) = default;
virtual int delete_object(const DoutPrefixProvider* dpp,
optional_yield y,
bool prevent_versioning = false) override;
virtual int copy_object(User* user,
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,
const ceph::real_time* mod_ptr, const ceph::real_time* unmod_ptr,
bool high_precision_time,
const char* if_match, const char* if_nomatch,
AttrsMod attrs_mod, bool copy_if_newer, Attrs& attrs,
RGWObjCategory category, uint64_t olh_epoch,
boost::optional<ceph::real_time> delete_at,
std::string* version_id, std::string* tag, std::string* etag,
void (*progress_cb)(off_t, void *), void* progress_data,
const DoutPrefixProvider* dpp, optional_yield y) override;
virtual RGWAccessControlPolicy& get_acl(void) override { return acls; }
virtual int set_acl(const RGWAccessControlPolicy& acl) override { acls = acl; return 0; }
virtual int get_obj_state(const DoutPrefixProvider* dpp, RGWObjState **state, optional_yield y, bool follow_olh = true) override;
virtual int set_obj_attrs(const DoutPrefixProvider* dpp, Attrs* setattrs, Attrs* delattrs, optional_yield y) override;
virtual int get_obj_attrs(optional_yield y, const DoutPrefixProvider* dpp, rgw_obj* target_obj = NULL) override;
virtual int modify_obj_attrs(const char* attr_name, bufferlist& attr_val, optional_yield y, const DoutPrefixProvider* dpp) override;
virtual int delete_obj_attrs(const DoutPrefixProvider* dpp, const char* attr_name, optional_yield y) override;
virtual bool is_expired() override;
virtual void gen_rand_obj_instance_name() override;
virtual std::unique_ptr<Object> clone() override {
return std::unique_ptr<Object>(new DBObject(*this));
}
virtual std::unique_ptr<MPSerializer> get_serializer(const DoutPrefixProvider *dpp,
const std::string& lock_name) override;
virtual int transition(Bucket* bucket,
const rgw_placement_rule& placement_rule,
const real_time& mtime,
uint64_t olh_epoch,
const DoutPrefixProvider* dpp,
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;
/* Swift versioning */
virtual int swift_versioning_restore(bool& restored,
const DoutPrefixProvider* dpp, optional_yield y) override;
virtual int swift_versioning_copy(const DoutPrefixProvider* dpp,
optional_yield y) override;
/* OPs */
virtual std::unique_ptr<ReadOp> get_read_op() override;
virtual std::unique_ptr<DeleteOp> get_delete_op() override;
/* OMAP */
virtual int omap_get_vals_by_keys(const DoutPrefixProvider *dpp, const std::string& oid,
const std::set<std::string>& keys,
Attrs* vals) override;
virtual int omap_set_val_by_key(const DoutPrefixProvider *dpp, const std::string& key, bufferlist& val,
bool must_exist, optional_yield y) override;
virtual int chown(User& new_user, const DoutPrefixProvider* dpp, optional_yield y) override;
private:
int read_attrs(const DoutPrefixProvider* dpp, DB::Object::Read &read_op, optional_yield y, rgw_obj* target_obj = nullptr);
};
class MPDBSerializer : public StoreMPSerializer {
public:
MPDBSerializer(const DoutPrefixProvider *dpp, DBStore* store, DBObject* obj, const std::string& lock_name) {}
virtual int try_lock(const DoutPrefixProvider *dpp, utime_t dur, optional_yield y) override {return 0; }
virtual int unlock() override { return 0;}
};
class DBAtomicWriter : public StoreWriter {
protected:
rgw::sal::DBStore* store;
const rgw_user& owner;
const rgw_placement_rule *ptail_placement_rule;
uint64_t olh_epoch;
const std::string& unique_tag;
DBObject obj;
DB::Object op_target;
DB::Object::Write parent_op;
uint64_t total_data_size = 0; /* for total data being uploaded */
bufferlist head_data;
bufferlist tail_part_data;
uint64_t tail_part_offset;
uint64_t tail_part_size = 0; /* corresponds to each tail part being
written to dbstore */
public:
DBAtomicWriter(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
DBStore* _store,
const rgw_user& _owner,
const rgw_placement_rule *_ptail_placement_rule,
uint64_t _olh_epoch,
const std::string& _unique_tag);
~DBAtomicWriter() = default;
// prepare to start processing object data
virtual int prepare(optional_yield y) override;
// Process a bufferlist
virtual int process(bufferlist&& data, uint64_t offset) override;
// complete the operation and make its result visible to clients
virtual int complete(size_t accounted_size, const std::string& etag,
ceph::real_time *mtime, ceph::real_time set_mtime,
std::map<std::string, bufferlist>& attrs,
ceph::real_time delete_at,
const char *if_match, const char *if_nomatch,
const std::string *user_data,
rgw_zone_set *zones_trace, bool *canceled,
optional_yield y) override;
};
class DBMultipartWriter : public StoreWriter {
protected:
rgw::sal::DBStore* store;
const rgw_user& owner;
const rgw_placement_rule *ptail_placement_rule;
uint64_t olh_epoch;
rgw::sal::Object* head_obj;
std::string upload_id;
int part_num;
std::string oid; /* object->name() + "." + "upload_id" + "." + part_num */
std::unique_ptr<rgw::sal::Object> meta_obj;
DB::Object op_target;
DB::Object::Write parent_op;
std::string part_num_str;
uint64_t total_data_size = 0; /* for total data being uploaded */
bufferlist head_data;
bufferlist tail_part_data;
uint64_t tail_part_offset;
uint64_t tail_part_size = 0; /* corresponds to each tail part being
written to dbstore */
public:
DBMultipartWriter(const DoutPrefixProvider *dpp,
optional_yield y, MultipartUpload* upload,
rgw::sal::Object* obj,
DBStore* _store,
const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num, const std::string& part_num_str);
~DBMultipartWriter() = default;
// prepare to start processing object data
virtual int prepare(optional_yield y) override;
// Process a bufferlist
virtual int process(bufferlist&& data, uint64_t offset) override;
// complete the operation and make its result visible to clients
virtual int complete(size_t accounted_size, const std::string& etag,
ceph::real_time *mtime, ceph::real_time set_mtime,
std::map<std::string, bufferlist>& attrs,
ceph::real_time delete_at,
const char *if_match, const char *if_nomatch,
const std::string *user_data,
rgw_zone_set *zones_trace, bool *canceled,
optional_yield y) override;
};
class DBStore : public StoreDriver {
private:
/* DBStoreManager is used in case multiple
* connections are needed one for each tenant.
*/
DBStoreManager *dbsm;
/* default db (single connection). If needed
* multiple db handles (for eg., one for each tenant),
* use dbsm->getDB(tenant) */
DB *db;
DBZone zone;
RGWSyncModuleInstanceRef sync_module;
RGWLC* lc;
CephContext *cct;
const DoutPrefixProvider *dpp;
bool use_lc_thread;
public:
DBStore(): dbsm(nullptr), zone(this), cct(nullptr), dpp(nullptr),
use_lc_thread(false) {}
~DBStore() { delete dbsm; }
DBStore& set_run_lc_thread(bool _use_lc_thread) {
use_lc_thread = _use_lc_thread;
return *this;
}
virtual int initialize(CephContext *cct, const DoutPrefixProvider *dpp) override;
virtual const std::string get_name() const override {
return "dbstore";
}
virtual std::unique_ptr<User> get_user(const rgw_user& u) override;
virtual int get_user_by_access_key(const DoutPrefixProvider *dpp, const std::string& key, optional_yield y, std::unique_ptr<User>* user) override;
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;
virtual std::string get_cluster_id(const DoutPrefixProvider* dpp, optional_yield y);
virtual int get_bucket(const DoutPrefixProvider *dpp, User* u, const rgw_bucket& b, std::unique_ptr<Bucket>* bucket, optional_yield y) override;
virtual int get_bucket(User* u, const RGWBucketInfo& i, std::unique_ptr<Bucket>* bucket) override;
virtual int get_bucket(const DoutPrefixProvider *dpp, User* u, const std::string& tenant, const std::string&name, std::unique_ptr<Bucket>* bucket, optional_yield y) override;
virtual bool is_meta_master() override;
virtual int forward_request_to_master(const DoutPrefixProvider *dpp, User* user, obj_version* objv,
bufferlist& in_data, JSONParser *jp, req_info& info,
optional_yield y) override;
virtual int forward_iam_request_to_master(const DoutPrefixProvider *dpp, const RGWAccessKey& key, obj_version* objv,
bufferlist& in_data,
RGWXMLDecoder::XMLParser* parser, req_info& info,
optional_yield y) override;
virtual Zone* get_zone() { return &zone; }
virtual std::string zone_unique_id(uint64_t unique_num) override;
virtual std::string zone_unique_trans_id(const uint64_t unique_num) override;
virtual int get_zonegroup(const std::string& id, std::unique_ptr<ZoneGroup>* zonegroup) override;
virtual int list_all_zones(const DoutPrefixProvider* dpp, std::list<std::string>& zone_ids) override;
virtual int cluster_stat(RGWClusterStat& stats) override;
virtual std::unique_ptr<Lifecycle> get_lifecycle(void) override;
virtual std::unique_ptr<Notification> get_notification(
rgw::sal::Object* obj, rgw::sal::Object* src_obj, req_state* s,
rgw::notify::EventType event_type, optional_yield y, const std::string* object_name) override;
virtual std::unique_ptr<Notification> get_notification(
const DoutPrefixProvider* dpp, rgw::sal::Object* obj,
rgw::sal::Object* src_obj,
rgw::notify::EventType event_type, rgw::sal::Bucket* _bucket,
std::string& _user_id, std::string& _user_tenant, std::string& _req_id,
optional_yield y) override;
virtual RGWLC* get_rgwlc(void) override;
virtual RGWCoroutinesManagerRegistry* get_cr_registry() override { return NULL; }
virtual int log_usage(const DoutPrefixProvider *dpp, std::map<rgw_user_bucket, RGWUsageBatch>& usage_info, optional_yield y) override;
virtual int log_op(const DoutPrefixProvider *dpp, std::string& oid, bufferlist& bl) override;
virtual int register_to_service_map(const DoutPrefixProvider *dpp, const std::string& daemon_type,
const std::map<std::string, std::string>& meta) override;
virtual void get_ratelimit(RGWRateLimitInfo& bucket_ratelimit, RGWRateLimitInfo& user_ratelimit, RGWRateLimitInfo& anon_ratelimit) override;
virtual void get_quota(RGWQuota& quota) override;
virtual int set_buckets_enabled(const DoutPrefixProvider *dpp, std::vector<rgw_bucket>& buckets, bool enabled, optional_yield y) override;
virtual int get_sync_policy_handler(const DoutPrefixProvider *dpp,
std::optional<rgw_zone_id> zone,
std::optional<rgw_bucket> bucket,
RGWBucketSyncPolicyHandlerRef *phandler,
optional_yield y) override;
virtual RGWDataSyncStatusManager* get_data_sync_manager(const rgw_zone_id& source_zone) override;
virtual void wakeup_meta_sync_shards(std::set<int>& shard_ids) override { return; }
virtual void wakeup_data_sync_shards(const DoutPrefixProvider *dpp,
const rgw_zone_id& source_zone,
boost::container::flat_map<
int,
boost::container::flat_set<rgw_data_notify_entry>>& shard_ids) override { return; }
virtual int clear_usage(const DoutPrefixProvider *dpp, optional_yield y) override { return 0; }
virtual int read_all_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch,
uint32_t max_entries, bool *is_truncated,
RGWUsageIter& usage_iter,
std::map<rgw_user_bucket, rgw_usage_log_entry>& usage) override;
virtual int trim_all_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch, optional_yield y) override;
virtual int get_config_key_val(std::string name, bufferlist* bl) override;
virtual int meta_list_keys_init(const DoutPrefixProvider *dpp, const std::string& section, const std::string& marker, void** phandle) override;
virtual int meta_list_keys_next(const DoutPrefixProvider *dpp, void* handle, int max, std::list<std::string>& keys, bool* truncated) override;
virtual void meta_list_keys_complete(void* handle) override;
virtual std::string meta_get_marker(void *handle) override;
virtual int meta_remove(const DoutPrefixProvider *dpp, std::string& metadata_key, optional_yield y) override;
virtual const RGWSyncModuleInstanceRef& get_sync_module() { return sync_module; }
virtual std::string get_host_id() { return ""; }
virtual std::unique_ptr<LuaManager> get_lua_manager() override;
virtual std::unique_ptr<RGWRole> get_role(std::string name,
std::string tenant,
std::string path="",
std::string trust_policy="",
std::string max_session_duration_str="",
std::multimap<std::string,std::string> tags={}) override;
virtual std::unique_ptr<RGWRole> get_role(std::string id) override;
virtual std::unique_ptr<RGWRole> get_role(const RGWRoleInfo& info) override;
virtual int get_roles(const DoutPrefixProvider *dpp,
optional_yield y,
const std::string& path_prefix,
const std::string& tenant,
std::vector<std::unique_ptr<RGWRole>>& roles) override;
virtual std::unique_ptr<RGWOIDCProvider> get_oidc_provider() override;
virtual int get_oidc_providers(const DoutPrefixProvider *dpp,
const std::string& tenant,
std::vector<std::unique_ptr<RGWOIDCProvider>>& providers, optional_yield y) override;
virtual std::unique_ptr<Writer> get_append_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
const rgw_user& 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,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag) override;
virtual const std::string& get_compression_type(const rgw_placement_rule& rule) override;
virtual bool valid_placement(const rgw_placement_rule& rule) override;
virtual void finalize(void) override;
virtual CephContext *ctx(void) override {
return db->ctx();
}
virtual void register_admin_apis(RGWRESTMgr* mgr) override { };
/* Unique to DBStore */
void setDBStoreManager(DBStoreManager *stm) { dbsm = stm; }
DBStoreManager *getDBStoreManager(void) { return dbsm; }
void setDB(DB * st) { db = st; }
DB *getDB(void) { return db; }
DB *getDB(std::string tenant) { return dbsm->getDB(tenant, false); }
};
} } // namespace rgw::sal
| 41,175 | 44.198683 | 262 |
h
|
null |
ceph-main/src/rgw/rgw_sal_filter.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2022 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "rgw_sal_filter.h"
namespace rgw { namespace sal {
/* These are helpers for getting 'next' out of an object, handling nullptr */
static inline PlacementTier* nextPlacementTier(PlacementTier* t)
{
if (!t)
return nullptr;
return dynamic_cast<FilterPlacementTier*>(t)->get_next();
}
static inline User* nextUser(User* t)
{
if (!t)
return nullptr;
return dynamic_cast<FilterUser*>(t)->get_next();
}
static inline Bucket* nextBucket(Bucket* t)
{
if (!t)
return nullptr;
return dynamic_cast<FilterBucket*>(t)->get_next();
}
static inline Object* nextObject(Object* t)
{
if (!t)
return nullptr;
return dynamic_cast<FilterObject*>(t)->get_next();
}
int FilterZoneGroup::get_placement_tier(const rgw_placement_rule& rule,
std::unique_ptr<PlacementTier>* tier)
{
std::unique_ptr<PlacementTier> nt;
int ret;
ret = next->get_placement_tier(rule, &nt);
if (ret != 0)
return ret;
PlacementTier* t = new FilterPlacementTier(std::move(nt));
tier->reset(t);
return 0;
}
int FilterZoneGroup::get_zone_by_id(const std::string& id, std::unique_ptr<Zone>* zone)
{
std::unique_ptr<Zone> nz;
int ret = next->get_zone_by_id(id, &nz);
if (ret < 0)
return ret;
Zone *z = new FilterZone(std::move(nz));
zone->reset(z);
return 0;
}
int FilterZoneGroup::get_zone_by_name(const std::string& name, std::unique_ptr<Zone>* zone)
{
std::unique_ptr<Zone> nz;
int ret = next->get_zone_by_name(name, &nz);
if (ret < 0)
return ret;
Zone *z = new FilterZone(std::move(nz));
zone->reset(z);
return 0;
}
int FilterDriver::initialize(CephContext *cct, const DoutPrefixProvider *dpp)
{
zone = std::make_unique<FilterZone>(next->get_zone()->clone());
return 0;
}
const std::string FilterDriver::get_name() const
{
std::string name = "filter<" + next->get_name() + ">";
return name;
}
std::string FilterDriver::get_cluster_id(const DoutPrefixProvider* dpp, optional_yield y)
{
return next->get_cluster_id(dpp, y);
}
std::unique_ptr<User> FilterDriver::get_user(const rgw_user &u)
{
std::unique_ptr<User> user = next->get_user(u);
return std::make_unique<FilterUser>(std::move(user));
}
int FilterDriver::get_user_by_access_key(const DoutPrefixProvider* dpp, const std::string& key, optional_yield y, std::unique_ptr<User>* user)
{
std::unique_ptr<User> nu;
int ret;
ret = next->get_user_by_access_key(dpp, key, y, &nu);
if (ret != 0)
return ret;
User* u = new FilterUser(std::move(nu));
user->reset(u);
return 0;
}
int FilterDriver::get_user_by_email(const DoutPrefixProvider* dpp, const std::string& email, optional_yield y, std::unique_ptr<User>* user)
{
std::unique_ptr<User> nu;
int ret;
ret = next->get_user_by_email(dpp, email, y, &nu);
if (ret != 0)
return ret;
User* u = new FilterUser(std::move(nu));
user->reset(u);
return 0;
}
int FilterDriver::get_user_by_swift(const DoutPrefixProvider* dpp, const std::string& user_str, optional_yield y, std::unique_ptr<User>* user)
{
std::unique_ptr<User> nu;
int ret;
ret = next->get_user_by_swift(dpp, user_str, y, &nu);
if (ret != 0)
return ret;
User* u = new FilterUser(std::move(nu));
user->reset(u);
return 0;
}
std::unique_ptr<Object> FilterDriver::get_object(const rgw_obj_key& k)
{
std::unique_ptr<Object> o = next->get_object(k);
return std::make_unique<FilterObject>(std::move(o));
}
int FilterDriver::get_bucket(const DoutPrefixProvider* dpp, User* u, const rgw_bucket& b, std::unique_ptr<Bucket>* bucket, optional_yield y)
{
std::unique_ptr<Bucket> nb;
int ret;
User* nu = nextUser(u);
ret = next->get_bucket(dpp, nu, b, &nb, y);
if (ret != 0)
return ret;
Bucket* fb = new FilterBucket(std::move(nb), u);
bucket->reset(fb);
return 0;
}
int FilterDriver::get_bucket(User* u, const RGWBucketInfo& i, std::unique_ptr<Bucket>* bucket)
{
std::unique_ptr<Bucket> nb;
int ret;
User* nu = nextUser(u);
ret = next->get_bucket(nu, i, &nb);
if (ret != 0)
return ret;
Bucket* fb = new FilterBucket(std::move(nb), u);
bucket->reset(fb);
return 0;
}
int FilterDriver::get_bucket(const DoutPrefixProvider* dpp, User* u, const std::string& tenant, const std::string& name, std::unique_ptr<Bucket>* bucket, optional_yield y)
{
std::unique_ptr<Bucket> nb;
int ret;
User* nu = nextUser(u);
ret = next->get_bucket(dpp, nu, tenant, name, &nb, y);
if (ret != 0)
return ret;
Bucket* fb = new FilterBucket(std::move(nb), u);
bucket->reset(fb);
return 0;
}
bool FilterDriver::is_meta_master()
{
return next->is_meta_master();
}
int FilterDriver::forward_request_to_master(const DoutPrefixProvider *dpp,
User* user, obj_version* objv,
bufferlist& in_data,
JSONParser* jp, req_info& info,
optional_yield y)
{
return next->forward_request_to_master(dpp, user, objv, in_data, jp, info, y);
}
int FilterDriver::forward_iam_request_to_master(const DoutPrefixProvider *dpp,
const RGWAccessKey& key,
obj_version* objv,
bufferlist& in_data,
RGWXMLDecoder::XMLParser* parser,
req_info& info,
optional_yield y)
{
return next->forward_iam_request_to_master(dpp, key, objv, in_data, parser, info, y);
}
std::string FilterDriver::zone_unique_id(uint64_t unique_num)
{
return next->zone_unique_id(unique_num);
}
std::string FilterDriver::zone_unique_trans_id(uint64_t unique_num)
{
return next->zone_unique_trans_id(unique_num);
}
int FilterDriver::get_zonegroup(const std::string& id,
std::unique_ptr<ZoneGroup>* zonegroup)
{
std::unique_ptr<ZoneGroup> ngz;
int ret;
ret = next->get_zonegroup(id, &ngz);
if (ret != 0)
return ret;
ZoneGroup* zg = new FilterZoneGroup(std::move(ngz));
zonegroup->reset(zg);
return 0;
}
int FilterDriver::cluster_stat(RGWClusterStat& stats)
{
return next->cluster_stat(stats);
}
std::unique_ptr<Lifecycle> FilterDriver::get_lifecycle(void)
{
std::unique_ptr<Lifecycle> lc = next->get_lifecycle();
return std::make_unique<FilterLifecycle>(std::move(lc));
}
std::unique_ptr<Notification> FilterDriver::get_notification(rgw::sal::Object* obj,
rgw::sal::Object* src_obj, req_state* s,
rgw::notify::EventType event_type, optional_yield y,
const std::string* object_name)
{
std::unique_ptr<Notification> n = next->get_notification(nextObject(obj),
nextObject(src_obj),
s, event_type, y,
object_name);
return std::make_unique<FilterNotification>(std::move(n));
}
std::unique_ptr<Notification> FilterDriver::get_notification(const DoutPrefixProvider* dpp,
rgw::sal::Object* obj, rgw::sal::Object* src_obj,
rgw::notify::EventType event_type,
rgw::sal::Bucket* _bucket, std::string& _user_id,
std::string& _user_tenant, std::string& _req_id,
optional_yield y)
{
std::unique_ptr<Notification> n = next->get_notification(dpp, nextObject(obj),
nextObject(src_obj),
event_type,
nextBucket(_bucket),
_user_id,
_user_tenant,
_req_id, y);
return std::make_unique<FilterNotification>(std::move(n));
}
RGWLC* FilterDriver::get_rgwlc()
{
return next->get_rgwlc();
}
RGWCoroutinesManagerRegistry* FilterDriver::get_cr_registry()
{
return next->get_cr_registry();
}
int FilterDriver::log_usage(const DoutPrefixProvider *dpp, std::map<rgw_user_bucket, RGWUsageBatch>& usage_info, optional_yield y)
{
return next->log_usage(dpp, usage_info, y);
}
int FilterDriver::log_op(const DoutPrefixProvider *dpp, std::string& oid, bufferlist& bl)
{
return next->log_op(dpp, oid, bl);
}
int FilterDriver::register_to_service_map(const DoutPrefixProvider *dpp,
const std::string& daemon_type,
const std::map<std::string, std::string>& meta)
{
return next->register_to_service_map(dpp, daemon_type, meta);
}
void FilterDriver::get_quota(RGWQuota& quota)
{
return next->get_quota(quota);
}
void FilterDriver::get_ratelimit(RGWRateLimitInfo& bucket_ratelimit,
RGWRateLimitInfo& user_ratelimit,
RGWRateLimitInfo& anon_ratelimit)
{
return next->get_ratelimit(bucket_ratelimit, user_ratelimit, anon_ratelimit);
}
int FilterDriver::set_buckets_enabled(const DoutPrefixProvider* dpp,
std::vector<rgw_bucket>& buckets, bool enabled, optional_yield y)
{
return next->set_buckets_enabled(dpp, buckets, enabled, y);
}
uint64_t FilterDriver::get_new_req_id()
{
return next->get_new_req_id();
}
int FilterDriver::get_sync_policy_handler(const DoutPrefixProvider* dpp,
std::optional<rgw_zone_id> zone,
std::optional<rgw_bucket> bucket,
RGWBucketSyncPolicyHandlerRef* phandler,
optional_yield y)
{
return next->get_sync_policy_handler(dpp, zone, bucket, phandler, y);
}
RGWDataSyncStatusManager* FilterDriver::get_data_sync_manager(const rgw_zone_id& source_zone)
{
return next->get_data_sync_manager(source_zone);
}
void FilterDriver::wakeup_meta_sync_shards(std::set<int>& shard_ids)
{
return next->wakeup_meta_sync_shards(shard_ids);
}
void FilterDriver::wakeup_data_sync_shards(const DoutPrefixProvider *dpp,
const rgw_zone_id& source_zone,
boost::container::flat_map<int, boost::container::flat_set<rgw_data_notify_entry>>& shard_ids)
{
return next->wakeup_data_sync_shards(dpp, source_zone, shard_ids);
}
int FilterDriver::clear_usage(const DoutPrefixProvider *dpp, optional_yield y)
{
return next->clear_usage(dpp, y);
}
int FilterDriver::read_all_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch,
uint64_t end_epoch, uint32_t max_entries,
bool* is_truncated, RGWUsageIter& usage_iter,
std::map<rgw_user_bucket, rgw_usage_log_entry>& usage)
{
return next->read_all_usage(dpp, start_epoch, end_epoch, max_entries,
is_truncated, usage_iter, usage);
}
int FilterDriver::trim_all_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch,
uint64_t end_epoch, optional_yield y)
{
return next->trim_all_usage(dpp, start_epoch, end_epoch, y);
}
int FilterDriver::get_config_key_val(std::string name, bufferlist* bl)
{
return next->get_config_key_val(name, bl);
}
int FilterDriver::meta_list_keys_init(const DoutPrefixProvider *dpp,
const std::string& section,
const std::string& marker, void** phandle)
{
return next->meta_list_keys_init(dpp, section, marker, phandle);
}
int FilterDriver::meta_list_keys_next(const DoutPrefixProvider *dpp, void* handle,
int max, std::list<std::string>& keys,
bool* truncated)
{
return next->meta_list_keys_next(dpp, handle, max, keys, truncated);
}
void FilterDriver::meta_list_keys_complete(void* handle)
{
next->meta_list_keys_complete(handle);
}
std::string FilterDriver::meta_get_marker(void* handle)
{
return next->meta_get_marker(handle);
}
int FilterDriver::meta_remove(const DoutPrefixProvider* dpp, std::string& metadata_key,
optional_yield y)
{
return next->meta_remove(dpp, metadata_key, y);
}
const RGWSyncModuleInstanceRef& FilterDriver::get_sync_module()
{
return next->get_sync_module();
}
std::unique_ptr<LuaManager> FilterDriver::get_lua_manager()
{
std::unique_ptr<LuaManager> nm = next->get_lua_manager();
return std::make_unique<FilterLuaManager>(std::move(nm));
}
std::unique_ptr<RGWRole> FilterDriver::get_role(std::string name,
std::string tenant,
std::string path,
std::string trust_policy,
std::string max_session_duration_str,
std::multimap<std::string,std::string> tags)
{
return next->get_role(name, tenant, path, trust_policy, max_session_duration_str, tags);
}
std::unique_ptr<RGWRole> FilterDriver::get_role(std::string id)
{
return next->get_role(id);
}
std::unique_ptr<RGWRole> FilterDriver::get_role(const RGWRoleInfo& info)
{
return next->get_role(info);
}
int FilterDriver::get_roles(const DoutPrefixProvider *dpp,
optional_yield y,
const std::string& path_prefix,
const std::string& tenant,
std::vector<std::unique_ptr<RGWRole>>& roles)
{
return next->get_roles(dpp, y, path_prefix, tenant, roles);
}
std::unique_ptr<RGWOIDCProvider> FilterDriver::get_oidc_provider()
{
return next->get_oidc_provider();
}
int FilterDriver::get_oidc_providers(const DoutPrefixProvider *dpp,
const std::string& tenant,
std::vector<std::unique_ptr<RGWOIDCProvider>>& providers, optional_yield y)
{
return next->get_oidc_providers(dpp, tenant, providers, y);
}
std::unique_ptr<Writer> FilterDriver::get_append_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
const rgw_user& 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> writer = next->get_append_writer(dpp, y, nextObject(obj),
owner, ptail_placement_rule,
unique_tag, position,
cur_accounted_size);
return std::make_unique<FilterWriter>(std::move(writer), obj);
}
std::unique_ptr<Writer> FilterDriver::get_atomic_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag)
{
std::unique_ptr<Writer> writer = next->get_atomic_writer(dpp, y, nextObject(obj),
owner, ptail_placement_rule,
olh_epoch, unique_tag);
return std::make_unique<FilterWriter>(std::move(writer), obj);
}
const std::string& FilterDriver::get_compression_type(const rgw_placement_rule& rule)
{
return next->get_compression_type(rule);
}
bool FilterDriver::valid_placement(const rgw_placement_rule& rule)
{
return next->valid_placement(rule);
}
void FilterDriver::finalize(void)
{
next->finalize();
}
CephContext* FilterDriver::ctx(void)
{
return next->ctx();
}
int FilterUser::list_buckets(const DoutPrefixProvider* dpp, const std::string& marker,
const std::string& end_marker, uint64_t max,
bool need_stats, BucketList &buckets, optional_yield y)
{
BucketList bl;
int ret;
buckets.clear();
ret = next->list_buckets(dpp, marker, end_marker, max, need_stats, bl, y);
if (ret < 0)
return ret;
buckets.set_truncated(bl.is_truncated());
for (auto& ent : bl.get_buckets()) {
buckets.add(std::make_unique<FilterBucket>(std::move(ent.second), this));
}
return 0;
}
int FilterUser::create_bucket(const DoutPrefixProvider* dpp,
const rgw_bucket& b,
const std::string& zonegroup_id,
rgw_placement_rule& placement_rule,
std::string& swift_ver_location,
const RGWQuotaInfo * pquota_info,
const RGWAccessControlPolicy& policy,
Attrs& attrs,
RGWBucketInfo& info,
obj_version& ep_objv,
bool exclusive,
bool obj_lock_enabled,
bool* existed,
req_info& req_info,
std::unique_ptr<Bucket>* bucket_out,
optional_yield y)
{
std::unique_ptr<Bucket> nb;
int ret;
ret = next->create_bucket(dpp, b, zonegroup_id, placement_rule, swift_ver_location, pquota_info, policy, attrs, info, ep_objv, exclusive, obj_lock_enabled, existed, req_info, &nb, y);
if (ret < 0)
return ret;
Bucket* fb = new FilterBucket(std::move(nb), this);
bucket_out->reset(fb);
return 0;
}
int FilterUser::read_attrs(const DoutPrefixProvider* dpp, optional_yield y)
{
return next->read_attrs(dpp, y);
}
int FilterUser::merge_and_store_attrs(const DoutPrefixProvider* dpp,
Attrs& new_attrs, optional_yield y)
{
return next->merge_and_store_attrs(dpp, new_attrs, y);
}
int FilterUser::read_stats(const DoutPrefixProvider *dpp,
optional_yield y, RGWStorageStats* stats,
ceph::real_time* last_stats_sync,
ceph::real_time* last_stats_update)
{
return next->read_stats(dpp, y, stats, last_stats_sync, last_stats_update);
}
int FilterUser::read_stats_async(const DoutPrefixProvider *dpp, RGWGetUserStats_CB* cb)
{
return next->read_stats_async(dpp, cb);
}
int FilterUser::complete_flush_stats(const DoutPrefixProvider *dpp, optional_yield y)
{
return next->complete_flush_stats(dpp, y);
}
int FilterUser::read_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch,
uint64_t end_epoch, uint32_t max_entries,
bool* is_truncated, RGWUsageIter& usage_iter,
std::map<rgw_user_bucket, rgw_usage_log_entry>& usage)
{
return next->read_usage(dpp, start_epoch, end_epoch, max_entries,
is_truncated, usage_iter, usage);
}
int FilterUser::trim_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch,
uint64_t end_epoch, optional_yield y)
{
return next->trim_usage(dpp, start_epoch, end_epoch, y);
}
int FilterUser::load_user(const DoutPrefixProvider* dpp, optional_yield y)
{
return next->load_user(dpp, y);
}
int FilterUser::store_user(const DoutPrefixProvider* dpp, optional_yield y, bool exclusive, RGWUserInfo* old_info)
{
return next->store_user(dpp, y, exclusive, old_info);
}
int FilterUser::remove_user(const DoutPrefixProvider* dpp, optional_yield y)
{
return next->remove_user(dpp, y);
}
int FilterUser::verify_mfa(const std::string& mfa_str, bool* verified,
const DoutPrefixProvider* dpp, optional_yield y)
{
return next->verify_mfa(mfa_str, verified, dpp, y);
}
std::unique_ptr<Object> FilterBucket::get_object(const rgw_obj_key& k)
{
std::unique_ptr<Object> o = next->get_object(k);
return std::make_unique<FilterObject>(std::move(o), this);
}
int FilterBucket::list(const DoutPrefixProvider* dpp, ListParams& params, int max,
ListResults& results, optional_yield y)
{
return next->list(dpp, params, max, results, y);
}
int FilterBucket::remove_bucket(const DoutPrefixProvider* dpp,
bool delete_children,
bool forward_to_master,
req_info* req_info,
optional_yield y)
{
return next->remove_bucket(dpp, delete_children, forward_to_master, req_info, y);
}
int FilterBucket::remove_bucket_bypass_gc(int concurrent_max,
bool keep_index_consistent,
optional_yield y,
const DoutPrefixProvider *dpp)
{
return next->remove_bucket_bypass_gc(concurrent_max, keep_index_consistent, y, dpp);
}
int FilterBucket::set_acl(const DoutPrefixProvider* dpp,
RGWAccessControlPolicy &acl, optional_yield y)
{
return next->set_acl(dpp, acl, y);
}
int FilterBucket::load_bucket(const DoutPrefixProvider* dpp, optional_yield y,
bool get_stats)
{
return next->load_bucket(dpp, y, get_stats);
}
int FilterBucket::read_stats(const DoutPrefixProvider *dpp,
const bucket_index_layout_generation& idx_layout,
int shard_id, std::string* bucket_ver,
std::string* master_ver,
std::map<RGWObjCategory, RGWStorageStats>& stats,
std::string* max_marker, bool* syncstopped)
{
return next->read_stats(dpp, idx_layout, shard_id, bucket_ver, master_ver,
stats, max_marker, syncstopped);
}
int FilterBucket::read_stats_async(const DoutPrefixProvider *dpp,
const bucket_index_layout_generation& idx_layout,
int shard_id, RGWGetBucketStats_CB* ctx)
{
return next->read_stats_async(dpp, idx_layout, shard_id, ctx);
}
int FilterBucket::sync_user_stats(const DoutPrefixProvider *dpp, optional_yield y)
{
return next->sync_user_stats(dpp, y);
}
int FilterBucket::update_container_stats(const DoutPrefixProvider* dpp, optional_yield y)
{
return next->update_container_stats(dpp, y);
}
int FilterBucket::check_bucket_shards(const DoutPrefixProvider* dpp, optional_yield y)
{
return next->check_bucket_shards(dpp, y);
}
int FilterBucket::chown(const DoutPrefixProvider* dpp, User& new_user, optional_yield y)
{
return next->chown(dpp, new_user, y);
}
int FilterBucket::put_info(const DoutPrefixProvider* dpp, bool exclusive,
ceph::real_time _mtime, optional_yield y)
{
return next->put_info(dpp, exclusive, _mtime, y);
}
bool FilterBucket::is_owner(User* user)
{
return next->is_owner(nextUser(user));
}
int FilterBucket::check_empty(const DoutPrefixProvider* dpp, optional_yield y)
{
return next->check_empty(dpp, y);
}
int FilterBucket::check_quota(const DoutPrefixProvider *dpp, RGWQuota& quota,
uint64_t obj_size, optional_yield y,
bool check_size_only)
{
return next->check_quota(dpp, quota, obj_size, y, check_size_only);
}
int FilterBucket::merge_and_store_attrs(const DoutPrefixProvider* dpp,
Attrs& new_attrs, optional_yield y)
{
return next->merge_and_store_attrs(dpp, new_attrs, y);
}
int FilterBucket::try_refresh_info(const DoutPrefixProvider* dpp,
ceph::real_time* pmtime, optional_yield y)
{
return next->try_refresh_info(dpp, pmtime, y);
}
int FilterBucket::read_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch,
uint64_t end_epoch, uint32_t max_entries,
bool* is_truncated, RGWUsageIter& usage_iter,
std::map<rgw_user_bucket, rgw_usage_log_entry>& usage)
{
return next->read_usage(dpp, start_epoch, end_epoch, max_entries,
is_truncated, usage_iter, usage);
}
int FilterBucket::trim_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch,
uint64_t end_epoch, optional_yield y)
{
return next->trim_usage(dpp, start_epoch, end_epoch, y);
}
int FilterBucket::remove_objs_from_index(const DoutPrefixProvider *dpp,
std::list<rgw_obj_index_key>& objs_to_unlink)
{
return next->remove_objs_from_index(dpp, objs_to_unlink);
}
int FilterBucket::check_index(const DoutPrefixProvider *dpp,
std::map<RGWObjCategory, RGWStorageStats>& existing_stats,
std::map<RGWObjCategory, RGWStorageStats>& calculated_stats)
{
return next->check_index(dpp, existing_stats, calculated_stats);
}
int FilterBucket::rebuild_index(const DoutPrefixProvider *dpp)
{
return next->rebuild_index(dpp);
}
int FilterBucket::set_tag_timeout(const DoutPrefixProvider *dpp, uint64_t timeout)
{
return next->set_tag_timeout(dpp, timeout);
}
int FilterBucket::purge_instance(const DoutPrefixProvider* dpp, optional_yield y)
{
return next->purge_instance(dpp, y);
}
std::unique_ptr<MultipartUpload> FilterBucket::get_multipart_upload(
const std::string& oid,
std::optional<std::string> upload_id,
ACLOwner owner, ceph::real_time mtime)
{
std::unique_ptr<MultipartUpload> nmu =
next->get_multipart_upload(oid, upload_id, owner, mtime);
return std::make_unique<FilterMultipartUpload>(std::move(nmu), this);
}
int FilterBucket::list_multiparts(const DoutPrefixProvider *dpp,
const std::string& prefix,
std::string& marker,
const std::string& delim,
const int& max_uploads,
std::vector<std::unique_ptr<MultipartUpload>>& uploads,
std::map<std::string, bool> *common_prefixes,
bool *is_truncated, optional_yield y)
{
std::vector<std::unique_ptr<MultipartUpload>> nup;
int ret;
ret = next->list_multiparts(dpp, prefix, marker, delim, max_uploads, nup,
common_prefixes, is_truncated, y);
if (ret < 0)
return ret;
for (auto& ent : nup) {
uploads.emplace_back(std::make_unique<FilterMultipartUpload>(std::move(ent), this));
}
return 0;
}
int FilterBucket::abort_multiparts(const DoutPrefixProvider* dpp, CephContext* cct, optional_yield y)
{
return next->abort_multiparts(dpp, cct, y);
}
int FilterObject::delete_object(const DoutPrefixProvider* dpp,
optional_yield y,
bool prevent_versioning)
{
return next->delete_object(dpp, y, prevent_versioning);
}
int FilterObject::copy_object(User* user,
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,
const ceph::real_time* mod_ptr,
const ceph::real_time* unmod_ptr,
bool high_precision_time,
const char* if_match,
const char* if_nomatch,
AttrsMod attrs_mod,
bool copy_if_newer,
Attrs& attrs,
RGWObjCategory category,
uint64_t olh_epoch,
boost::optional<ceph::real_time> delete_at,
std::string* version_id,
std::string* tag,
std::string* etag,
void (*progress_cb)(off_t, void *),
void* progress_data,
const DoutPrefixProvider* dpp,
optional_yield y)
{
return next->copy_object(user, info, source_zone,
nextObject(dest_object),
nextBucket(dest_bucket),
nextBucket(src_bucket),
dest_placement, src_mtime, mtime,
mod_ptr, unmod_ptr, high_precision_time, if_match,
if_nomatch, attrs_mod, copy_if_newer, attrs,
category, olh_epoch, delete_at, version_id, tag,
etag, progress_cb, progress_data, dpp, y);
}
RGWAccessControlPolicy& FilterObject::get_acl()
{
return next->get_acl();
}
int FilterObject::get_obj_state(const DoutPrefixProvider* dpp, RGWObjState **pstate,
optional_yield y, bool follow_olh)
{
return next->get_obj_state(dpp, pstate, y, follow_olh);
}
int FilterObject::set_obj_attrs(const DoutPrefixProvider* dpp, Attrs* setattrs,
Attrs* delattrs, optional_yield y)
{
return next->set_obj_attrs(dpp, setattrs, delattrs, y);
}
int FilterObject::get_obj_attrs(optional_yield y, const DoutPrefixProvider* dpp,
rgw_obj* target_obj)
{
return next->get_obj_attrs(y, dpp, target_obj);
}
int FilterObject::modify_obj_attrs(const char* attr_name, bufferlist& attr_val,
optional_yield y, const DoutPrefixProvider* dpp)
{
return next->modify_obj_attrs(attr_name, attr_val, y, dpp);
}
int FilterObject::delete_obj_attrs(const DoutPrefixProvider* dpp,
const char* attr_name, optional_yield y)
{
return next->delete_obj_attrs(dpp, attr_name, y);
}
bool FilterObject::is_expired()
{
return next->is_expired();
}
void FilterObject::gen_rand_obj_instance_name()
{
return next->gen_rand_obj_instance_name();
}
std::unique_ptr<MPSerializer> FilterObject::get_serializer(const DoutPrefixProvider *dpp,
const std::string& lock_name)
{
std::unique_ptr<MPSerializer> s = next->get_serializer(dpp, lock_name);
return std::make_unique<FilterMPSerializer>(std::move(s));
}
int FilterObject::transition(Bucket* bucket,
const rgw_placement_rule& placement_rule,
const real_time& mtime,
uint64_t olh_epoch,
const DoutPrefixProvider* dpp,
optional_yield y)
{
return next->transition(nextBucket(bucket), placement_rule, mtime, olh_epoch,
dpp, y);
}
int FilterObject::transition_to_cloud(Bucket* bucket,
rgw::sal::PlacementTier* tier,
rgw_bucket_dir_entry& o,
std::set<std::string>& cloud_targets,
CephContext* cct,
bool update_object,
const DoutPrefixProvider* dpp,
optional_yield y)
{
return next->transition_to_cloud(nextBucket(bucket), nextPlacementTier(tier),
o, cloud_targets, cct, update_object, dpp, y);
}
bool FilterObject::placement_rules_match(rgw_placement_rule& r1, rgw_placement_rule& r2)
{
return next->placement_rules_match(r1, r2);
}
int FilterObject::dump_obj_layout(const DoutPrefixProvider *dpp, optional_yield y,
Formatter* f)
{
return next->dump_obj_layout(dpp, y, f);
}
void FilterObject::set_bucket(Bucket* b)
{
bucket = b;
next->set_bucket(nextBucket(b));
};
int FilterObject::swift_versioning_restore(bool& restored,
const DoutPrefixProvider* dpp, optional_yield y)
{
return next->swift_versioning_restore(restored, dpp, y);
}
int FilterObject::swift_versioning_copy(const DoutPrefixProvider* dpp,
optional_yield y)
{
return next->swift_versioning_copy(dpp, y);
}
std::unique_ptr<Object::ReadOp> FilterObject::get_read_op()
{
std::unique_ptr<ReadOp> r = next->get_read_op();
return std::make_unique<FilterReadOp>(std::move(r));
}
std::unique_ptr<Object::DeleteOp> FilterObject::get_delete_op()
{
std::unique_ptr<DeleteOp> d = next->get_delete_op();
return std::make_unique<FilterDeleteOp>(std::move(d));
}
int FilterObject::get_torrent_info(const DoutPrefixProvider* dpp,
optional_yield y, bufferlist& bl)
{
return next->get_torrent_info(dpp, y, bl);
}
int FilterObject::omap_get_vals_by_keys(const DoutPrefixProvider *dpp,
const std::string& oid,
const std::set<std::string>& keys,
Attrs* vals)
{
return next->omap_get_vals_by_keys(dpp, oid, keys, vals);
}
int FilterObject::omap_set_val_by_key(const DoutPrefixProvider *dpp,
const std::string& key, bufferlist& val,
bool must_exist, optional_yield y)
{
return next->omap_set_val_by_key(dpp, key, val, must_exist, y);
}
int FilterObject::chown(User& new_user, const DoutPrefixProvider* dpp, optional_yield y)
{
return next->chown(new_user, dpp, y);
}
int FilterObject::FilterReadOp::prepare(optional_yield y, const DoutPrefixProvider* dpp)
{
/* Copy params into next */
next->params = params;
return next->prepare(y, dpp);
}
int FilterObject::FilterReadOp::read(int64_t ofs, int64_t end, bufferlist& bl,
optional_yield y, const DoutPrefixProvider* dpp)
{
int ret = next->read(ofs, end, bl, y, dpp);
if (ret < 0)
return ret;
/* Copy params out of next */
params = next->params;
return ret;
}
int FilterObject::FilterReadOp::get_attr(const DoutPrefixProvider* dpp, const char* name, bufferlist& dest, optional_yield y)
{
return next->get_attr(dpp, name, dest, y);
}
int FilterObject::FilterReadOp::iterate(const DoutPrefixProvider* dpp, int64_t ofs,
int64_t end, RGWGetDataCB* cb, optional_yield y)
{
int ret = next->iterate(dpp, ofs, end, cb, y);
if (ret < 0)
return ret;
/* Copy params out of next */
params = next->params;
return ret;
}
int FilterObject::FilterDeleteOp::delete_obj(const DoutPrefixProvider* dpp,
optional_yield y)
{
/* Copy params into next */
next->params = params;
int ret = next->delete_obj(dpp, y);
/* Copy result back */
result = next->result;
return ret;
}
std::unique_ptr<rgw::sal::Object> FilterMultipartUpload::get_meta_obj()
{
std::unique_ptr<Object> no = next->get_meta_obj();
return std::make_unique<FilterObject>(std::move(no), bucket);
}
int FilterMultipartUpload::init(const DoutPrefixProvider *dpp, optional_yield y,
ACLOwner& owner, rgw_placement_rule& dest_placement,
rgw::sal::Attrs& attrs)
{
return next->init(dpp, y, owner, dest_placement, attrs);
}
int FilterMultipartUpload::list_parts(const DoutPrefixProvider *dpp, CephContext *cct,
int num_parts, int marker,
int *next_marker, bool *truncated, optional_yield y,
bool assume_unsorted)
{
int ret;
ret = next->list_parts(dpp, cct, num_parts, marker, next_marker, truncated, y,
assume_unsorted);
if (ret < 0)
return ret;
parts.clear();
for (auto& ent : next->get_parts()) {
parts.emplace(ent.first, std::make_unique<FilterMultipartPart>(std::move(ent.second)));
}
return 0;
}
int FilterMultipartUpload::abort(const DoutPrefixProvider *dpp, CephContext *cct, optional_yield y)
{
return next->abort(dpp, cct, y);
}
int FilterMultipartUpload::complete(const DoutPrefixProvider *dpp,
optional_yield y, CephContext* cct,
std::map<int, std::string>& part_etags,
std::list<rgw_obj_index_key>& remove_objs,
uint64_t& accounted_size, bool& compressed,
RGWCompressionInfo& cs_info, off_t& ofs,
std::string& tag, ACLOwner& owner,
uint64_t olh_epoch,
rgw::sal::Object* target_obj)
{
return next->complete(dpp, y, cct, part_etags, remove_objs, accounted_size,
compressed, cs_info, ofs, tag, owner, olh_epoch,
nextObject(target_obj));
}
int FilterMultipartUpload::get_info(const DoutPrefixProvider *dpp,
optional_yield y, rgw_placement_rule** rule,
rgw::sal::Attrs* attrs)
{
return next->get_info(dpp, y, rule, attrs);
}
std::unique_ptr<Writer> FilterMultipartUpload::get_writer(
const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num,
const std::string& part_num_str)
{
std::unique_ptr<Writer> writer;
writer = next->get_writer(dpp, y, nextObject(obj), owner,
ptail_placement_rule, part_num, part_num_str);
return std::make_unique<FilterWriter>(std::move(writer), obj);
}
int FilterMPSerializer::try_lock(const DoutPrefixProvider *dpp, utime_t dur,
optional_yield y)
{
return next->try_lock(dpp, dur, y);
}
int FilterLCSerializer::try_lock(const DoutPrefixProvider *dpp, utime_t dur,
optional_yield y)
{
return next->try_lock(dpp, dur, y);
}
std::unique_ptr<Lifecycle::LCEntry> FilterLifecycle::get_entry()
{
std::unique_ptr<Lifecycle::LCEntry> e = next->get_entry();
return std::make_unique<FilterLCEntry>(std::move(e));
}
int FilterLifecycle::get_entry(const std::string& oid, const std::string& marker,
std::unique_ptr<LCEntry>* entry)
{
std::unique_ptr<LCEntry> ne;
int ret;
ret = next->get_entry(oid, marker, &ne);
if (ret < 0)
return ret;
LCEntry* e = new FilterLCEntry(std::move(ne));
entry->reset(e);
return 0;
}
int FilterLifecycle::get_next_entry(const std::string& oid, const std::string& marker,
std::unique_ptr<LCEntry>* entry)
{
std::unique_ptr<LCEntry> ne;
int ret;
ret = next->get_next_entry(oid, marker, &ne);
if (ret < 0)
return ret;
LCEntry* e = new FilterLCEntry(std::move(ne));
entry->reset(e);
return 0;
}
int FilterLifecycle::set_entry(const std::string& oid, LCEntry& entry)
{
return next->set_entry(oid, entry);
}
int FilterLifecycle::list_entries(const std::string& oid, const std::string& marker,
uint32_t max_entries,
std::vector<std::unique_ptr<LCEntry>>& entries)
{
std::vector<std::unique_ptr<LCEntry>> ne;
int ret;
ret = next->list_entries(oid, marker, max_entries, ne);
if (ret < 0)
return ret;
for (auto& ent : ne) {
entries.emplace_back(std::make_unique<FilterLCEntry>(std::move(ent)));
}
return 0;
}
int FilterLifecycle::rm_entry(const std::string& oid, LCEntry& entry)
{
return next->rm_entry(oid, entry);
}
int FilterLifecycle::get_head(const std::string& oid, std::unique_ptr<LCHead>* head)
{
std::unique_ptr<LCHead> nh;
int ret;
ret = next->get_head(oid, &nh);
if (ret < 0)
return ret;
LCHead* h = new FilterLCHead(std::move(nh));
head->reset(h);
return 0;
}
int FilterLifecycle::put_head(const std::string& oid, LCHead& head)
{
return next->put_head(oid, *(dynamic_cast<FilterLCHead&>(head).next.get()));
}
std::unique_ptr<LCSerializer> FilterLifecycle::get_serializer(
const std::string& lock_name,
const std::string& oid,
const std::string& cookie)
{
std::unique_ptr<LCSerializer> ns;
ns = next->get_serializer(lock_name, oid, cookie);
return std::make_unique<FilterLCSerializer>(std::move(ns));
}
int FilterNotification::publish_reserve(const DoutPrefixProvider *dpp,
RGWObjTags* obj_tags)
{
return next->publish_reserve(dpp, obj_tags);
}
int FilterNotification::publish_commit(const DoutPrefixProvider* dpp, uint64_t size,
const ceph::real_time& mtime, const
std::string& etag, const std::string& version)
{
return next->publish_commit(dpp, size, mtime, etag, version);
}
int FilterWriter::process(bufferlist&& data, uint64_t offset)
{
return next->process(std::move(data), offset);
}
int FilterWriter::complete(size_t accounted_size, const std::string& etag,
ceph::real_time *mtime, ceph::real_time set_mtime,
std::map<std::string, bufferlist>& attrs,
ceph::real_time delete_at,
const char *if_match, const char *if_nomatch,
const std::string *user_data,
rgw_zone_set *zones_trace, bool *canceled,
optional_yield y)
{
return next->complete(accounted_size, etag, mtime, set_mtime, attrs,
delete_at, if_match, if_nomatch, user_data, zones_trace,
canceled, y);
}
int FilterLuaManager::get_script(const DoutPrefixProvider* dpp, optional_yield y,
const std::string& key, std::string& script)
{
return next->get_script(dpp, y, key, script);
}
int FilterLuaManager::put_script(const DoutPrefixProvider* dpp, optional_yield y,
const std::string& key, const std::string& script)
{
return next->put_script(dpp, y, key, script);
}
int FilterLuaManager::del_script(const DoutPrefixProvider* dpp, optional_yield y,
const std::string& key)
{
return next->del_script(dpp, y, key);
}
int FilterLuaManager::add_package(const DoutPrefixProvider* dpp, optional_yield y,
const std::string& package_name)
{
return next->add_package(dpp, y, package_name);
}
int FilterLuaManager::remove_package(const DoutPrefixProvider* dpp, optional_yield y,
const std::string& package_name)
{
return next->remove_package(dpp, y, package_name);
}
int FilterLuaManager::list_packages(const DoutPrefixProvider* dpp, optional_yield y,
rgw::lua::packages_t& packages)
{
return next->list_packages(dpp, y, packages);
}
} } // namespace rgw::sal
extern "C" {
rgw::sal::Driver* newBaseFilter(rgw::sal::Driver* next)
{
rgw::sal::FilterDriver* driver = new rgw::sal::FilterDriver(next);
return driver;
}
}
| 37,991 | 27.142222 | 185 |
cc
|
null |
ceph-main/src/rgw/rgw_sal_filter.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2022 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#pragma once
#include "rgw_sal.h"
#include "rgw_oidc_provider.h"
#include "rgw_role.h"
namespace rgw { namespace sal {
class FilterPlacementTier : public PlacementTier {
protected:
std::unique_ptr<PlacementTier> next;
public:
FilterPlacementTier(std::unique_ptr<PlacementTier> _next) : next(std::move(_next)) {}
virtual ~FilterPlacementTier() = default;
virtual const std::string& get_tier_type() override { return next->get_tier_type(); }
virtual const std::string& get_storage_class() override { return next->get_storage_class(); }
virtual bool retain_head_object() override { return next->retain_head_object(); }
/* Internal to Filters */
PlacementTier* get_next() { return next.get(); }
};
class FilterZoneGroup : public ZoneGroup {
protected:
std::unique_ptr<ZoneGroup> next;
public:
FilterZoneGroup(std::unique_ptr<ZoneGroup> _next) : next(std::move(_next)) {}
virtual ~FilterZoneGroup() = default;
virtual const std::string& get_id() const override
{ return next->get_id(); }
virtual const std::string& get_name() const override
{ return next->get_name(); }
virtual int equals(const std::string& other_zonegroup) const override
{ return next->equals(other_zonegroup); }
virtual const std::string& get_endpoint() const override
{ return next->get_endpoint(); }
virtual bool placement_target_exists(std::string& target) const override
{ return next->placement_target_exists(target); }
virtual bool is_master_zonegroup() const override
{ return next->is_master_zonegroup(); }
virtual const std::string& get_api_name() const override
{ return next->get_api_name(); }
virtual int get_placement_target_names(std::set<std::string>& names) const override
{ return next->get_placement_target_names(names); }
virtual const std::string& get_default_placement_name() const override
{ return next->get_default_placement_name(); }
virtual int get_hostnames(std::list<std::string>& names) const override
{ return next->get_hostnames(names); }
virtual int get_s3website_hostnames(std::list<std::string>& names) const override
{ return next->get_s3website_hostnames(names); }
virtual int get_zone_count() const override
{ return next->get_zone_count(); }
virtual int get_placement_tier(const rgw_placement_rule& rule, std::unique_ptr<PlacementTier>* tier) override;
virtual int get_zone_by_id(const std::string& id, std::unique_ptr<Zone>* zone) override;
virtual int get_zone_by_name(const std::string& name, std::unique_ptr<Zone>* zone) override;
virtual int list_zones(std::list<std::string>& zone_ids) override
{ return next->list_zones(zone_ids); }
virtual std::unique_ptr<ZoneGroup> clone() override {
std::unique_ptr<ZoneGroup> nzg = next->clone();
return std::make_unique<FilterZoneGroup>(std::move(nzg));
}
};
class FilterZone : public Zone {
protected:
std::unique_ptr<Zone> next;
private:
std::unique_ptr<ZoneGroup> group;
public:
FilterZone(std::unique_ptr<Zone> _next) : next(std::move(_next))
{
group = std::make_unique<FilterZoneGroup>(next->get_zonegroup().clone());
}
virtual ~FilterZone() = default;
virtual std::unique_ptr<Zone> clone() override {
std::unique_ptr<Zone> nz = next->clone();
return std::make_unique<FilterZone>(std::move(nz));
}
virtual ZoneGroup& get_zonegroup() override {
return *group.get();
}
virtual const std::string& get_id() override {
return next->get_id();
}
virtual const std::string& get_name() const override {
return next->get_name();
}
virtual bool is_writeable() override {
return next->is_writeable();
}
virtual bool get_redirect_endpoint(std::string* endpoint) override {
return next->get_redirect_endpoint(endpoint);
}
virtual bool has_zonegroup_api(const std::string& api) const override {
return next->has_zonegroup_api(api);
}
virtual const std::string& get_current_period_id() override {
return next->get_current_period_id();
}
virtual const RGWAccessKey& get_system_key() override {
return next->get_system_key();
}
virtual const std::string& get_realm_name() override {
return next->get_realm_name();
}
virtual const std::string& get_realm_id() override {
return next->get_realm_id();
}
virtual const std::string_view get_tier_type() override {
return next->get_tier_type();
}
virtual RGWBucketSyncPolicyHandlerRef get_sync_policy_handler() override {
return next->get_sync_policy_handler();
}
};
class FilterDriver : public Driver {
protected:
Driver* next;
private:
std::unique_ptr<FilterZone> zone;
public:
FilterDriver(Driver* _next) : next(_next) {}
virtual ~FilterDriver() = default;
virtual int initialize(CephContext *cct, const DoutPrefixProvider *dpp) override;
virtual const std::string get_name() const override;
virtual std::string get_cluster_id(const DoutPrefixProvider* dpp,
optional_yield y) override;
virtual std::unique_ptr<User> get_user(const rgw_user& u) override;
virtual int get_user_by_access_key(const DoutPrefixProvider* dpp, const
std::string& key, optional_yield y,
std::unique_ptr<User>* user) override;
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;
virtual int get_bucket(User* u, const RGWBucketInfo& i,
std::unique_ptr<Bucket>* bucket) override;
virtual int get_bucket(const DoutPrefixProvider* dpp, User* u, const
rgw_bucket& b, std::unique_ptr<Bucket>* bucket,
optional_yield y) override;
virtual int get_bucket(const DoutPrefixProvider* dpp, User* u, const
std::string& tenant, const std::string& name,
std::unique_ptr<Bucket>* bucket, optional_yield y) override;
virtual bool is_meta_master() override;
virtual int forward_request_to_master(const DoutPrefixProvider *dpp, User* user,
obj_version* objv, bufferlist& in_data,
JSONParser* jp, req_info& info,
optional_yield y) override;
virtual int forward_iam_request_to_master(const DoutPrefixProvider *dpp,
const RGWAccessKey& key,
obj_version* objv,
bufferlist& in_data,
RGWXMLDecoder::XMLParser* parser,
req_info& info,
optional_yield y) override;
virtual Zone* get_zone() override { return zone.get(); }
virtual std::string zone_unique_id(uint64_t unique_num) override;
virtual std::string zone_unique_trans_id(const uint64_t unique_num) override;
virtual int get_zonegroup(const std::string& id, std::unique_ptr<ZoneGroup>* zonegroup) override;
virtual int list_all_zones(const DoutPrefixProvider* dpp, std::list<std::string>& zone_ids) override {
return next->list_all_zones(dpp, zone_ids);
}
virtual int cluster_stat(RGWClusterStat& stats) override;
virtual std::unique_ptr<Lifecycle> get_lifecycle(void) override;
virtual std::unique_ptr<Notification> get_notification(rgw::sal::Object* obj,
rgw::sal::Object* src_obj, struct req_state* s,
rgw::notify::EventType event_type, optional_yield y,
const std::string* object_name=nullptr) override;
virtual std::unique_ptr<Notification> get_notification(
const DoutPrefixProvider* dpp, rgw::sal::Object* obj, rgw::sal::Object* src_obj,
rgw::notify::EventType event_type, rgw::sal::Bucket* _bucket,
std::string& _user_id, std::string& _user_tenant,
std::string& _req_id, optional_yield y) override;
int read_topics(const std::string& tenant, rgw_pubsub_topics& topics, RGWObjVersionTracker* objv_tracker,
optional_yield y, const DoutPrefixProvider *dpp) override {
return next->read_topics(tenant, topics, objv_tracker, y, dpp);
}
int write_topics(const std::string& tenant, const rgw_pubsub_topics& topics, RGWObjVersionTracker* objv_tracker,
optional_yield y, const DoutPrefixProvider *dpp) override {
return next->write_topics(tenant, topics, objv_tracker, y, dpp);
}
int remove_topics(const std::string& tenant, RGWObjVersionTracker* objv_tracker,
optional_yield y, const DoutPrefixProvider *dpp) override {
return next->remove_topics(tenant, objv_tracker, y, dpp);
}
virtual RGWLC* get_rgwlc(void) override;
virtual RGWCoroutinesManagerRegistry* get_cr_registry() override;
virtual int log_usage(const DoutPrefixProvider *dpp, std::map<rgw_user_bucket,
RGWUsageBatch>& usage_info, optional_yield y) override;
virtual int log_op(const DoutPrefixProvider *dpp, std::string& oid,
bufferlist& bl) override;
virtual int register_to_service_map(const DoutPrefixProvider *dpp, const
std::string& daemon_type,
const std::map<std::string,
std::string>& meta) override;
virtual void get_quota(RGWQuota& quota) override;
virtual void get_ratelimit(RGWRateLimitInfo& bucket_ratelimit,
RGWRateLimitInfo& user_ratelimit,
RGWRateLimitInfo& anon_ratelimit) override;
virtual int set_buckets_enabled(const DoutPrefixProvider* dpp,
std::vector<rgw_bucket>& buckets,
bool enabled, optional_yield y) override;
virtual uint64_t get_new_req_id() override;
virtual int get_sync_policy_handler(const DoutPrefixProvider* dpp,
std::optional<rgw_zone_id> zone,
std::optional<rgw_bucket> bucket,
RGWBucketSyncPolicyHandlerRef* phandler,
optional_yield y) override;
virtual RGWDataSyncStatusManager* get_data_sync_manager(const rgw_zone_id& source_zone) override;
virtual void wakeup_meta_sync_shards(std::set<int>& shard_ids) override;
virtual void wakeup_data_sync_shards(const DoutPrefixProvider *dpp,
const rgw_zone_id& source_zone,
boost::container::flat_map<int, boost::container::flat_set<rgw_data_notify_entry>>& shard_ids) override;
virtual int clear_usage(const DoutPrefixProvider *dpp, optional_yield y) override;
virtual int read_all_usage(const DoutPrefixProvider *dpp,
uint64_t start_epoch, uint64_t end_epoch,
uint32_t max_entries, bool* is_truncated,
RGWUsageIter& usage_iter,
std::map<rgw_user_bucket, rgw_usage_log_entry>& usage) override;
virtual int trim_all_usage(const DoutPrefixProvider *dpp,
uint64_t start_epoch, uint64_t end_epoch, optional_yield y) override;
virtual int get_config_key_val(std::string name, bufferlist* bl) override;
virtual int meta_list_keys_init(const DoutPrefixProvider *dpp,
const std::string& section,
const std::string& marker,
void** phandle) override;
virtual int meta_list_keys_next(const DoutPrefixProvider *dpp, void* handle,
int max, std::list<std::string>& keys,
bool* truncated) override;
virtual void meta_list_keys_complete(void* handle) override;
virtual std::string meta_get_marker(void* handle) override;
virtual int meta_remove(const DoutPrefixProvider* dpp,
std::string& metadata_key, optional_yield y) override;
virtual const RGWSyncModuleInstanceRef& get_sync_module() override;
virtual std::string get_host_id() override { return next->get_host_id(); }
virtual std::unique_ptr<LuaManager> get_lua_manager() override;
virtual std::unique_ptr<RGWRole> get_role(std::string name,
std::string tenant,
std::string path="",
std::string trust_policy="",
std::string
max_session_duration_str="",
std::multimap<std::string,std::string> tags={}) override;
virtual std::unique_ptr<RGWRole> get_role(std::string id) override;
virtual std::unique_ptr<RGWRole> get_role(const RGWRoleInfo& info) override;
virtual int get_roles(const DoutPrefixProvider *dpp,
optional_yield y,
const std::string& path_prefix,
const std::string& tenant,
std::vector<std::unique_ptr<RGWRole>>& roles) override;
virtual std::unique_ptr<RGWOIDCProvider> get_oidc_provider() override;
virtual int get_oidc_providers(const DoutPrefixProvider *dpp,
const std::string& tenant,
std::vector<std::unique_ptr<RGWOIDCProvider>>&
providers, optional_yield y) override;
virtual std::unique_ptr<Writer> get_append_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
const rgw_user& 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,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag) override;
virtual const std::string& get_compression_type(const rgw_placement_rule& rule) override;
virtual bool valid_placement(const rgw_placement_rule& rule) override;
virtual void finalize(void) override;
virtual CephContext* ctx(void) override;
virtual void register_admin_apis(RGWRESTMgr* mgr) override {
return next->register_admin_apis(mgr);
}
};
class FilterUser : public User {
protected:
std::unique_ptr<User> next;
public:
FilterUser(std::unique_ptr<User> _next) : next(std::move(_next)) {}
FilterUser(FilterUser& u) : next(u.next->clone()) {};
virtual ~FilterUser() = default;
virtual std::unique_ptr<User> clone() override {
return std::make_unique<FilterUser>(*this);
}
virtual int list_buckets(const DoutPrefixProvider* dpp,
const std::string& marker, const std::string& end_marker,
uint64_t max, bool need_stats, BucketList& buckets,
optional_yield y) override;
virtual int create_bucket(const DoutPrefixProvider* dpp,
const rgw_bucket& b,
const std::string& zonegroup_id,
rgw_placement_rule& placement_rule,
std::string& swift_ver_location,
const RGWQuotaInfo* pquota_info,
const RGWAccessControlPolicy& policy,
Attrs& attrs,
RGWBucketInfo& info,
obj_version& ep_objv,
bool exclusive,
bool obj_lock_enabled,
bool* existed,
req_info& req_info,
std::unique_ptr<Bucket>* bucket,
optional_yield y) override;
virtual std::string& get_display_name() override { return next->get_display_name(); }
virtual const std::string& get_tenant() override { return next->get_tenant(); }
virtual void set_tenant(std::string& _t) override { next->set_tenant(_t); }
virtual const std::string& get_ns() override { return next->get_ns(); }
virtual void set_ns(std::string& _ns) override { next->set_ns(_ns); }
virtual void clear_ns() override { next->clear_ns(); }
virtual const rgw_user& get_id() const override { return next->get_id(); }
virtual uint32_t get_type() const override { return next->get_type(); }
virtual int32_t get_max_buckets() const override { return next->get_max_buckets(); }
virtual void set_max_buckets(int32_t _max_buckets) override { return next->set_max_buckets(_max_buckets); }
virtual void set_info(RGWQuotaInfo& _quota) override { return next->set_info(_quota); }
virtual const RGWUserCaps& get_caps() const override { return next->get_caps(); }
virtual RGWObjVersionTracker& get_version_tracker() override {
return next->get_version_tracker();
}
virtual Attrs& get_attrs() override { return next->get_attrs(); }
virtual void set_attrs(Attrs& _attrs) override { next->set_attrs(_attrs); }
virtual bool empty() const override { return next->empty(); }
virtual int read_attrs(const DoutPrefixProvider* dpp, optional_yield y) override;
virtual int merge_and_store_attrs(const DoutPrefixProvider* dpp, Attrs&
new_attrs, optional_yield y) override;
virtual int read_stats(const DoutPrefixProvider *dpp,
optional_yield y, RGWStorageStats* stats,
ceph::real_time* last_stats_sync = nullptr,
ceph::real_time* last_stats_update = nullptr) override;
virtual int read_stats_async(const DoutPrefixProvider *dpp,
RGWGetUserStats_CB* cb) override;
virtual int complete_flush_stats(const DoutPrefixProvider *dpp, optional_yield y) override;
virtual int read_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch,
uint64_t end_epoch, uint32_t max_entries,
bool* is_truncated, RGWUsageIter& usage_iter,
std::map<rgw_user_bucket, rgw_usage_log_entry>& usage) override;
virtual int trim_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch,
uint64_t end_epoch, optional_yield y) override;
virtual int load_user(const DoutPrefixProvider* dpp, optional_yield y) override;
virtual int store_user(const DoutPrefixProvider* dpp, optional_yield y, bool
exclusive, RGWUserInfo* old_info = nullptr) override;
virtual int remove_user(const DoutPrefixProvider* dpp, optional_yield y) override;
virtual int verify_mfa(const std::string& mfa_str, bool* verified,
const DoutPrefixProvider* dpp, optional_yield y) override;
RGWUserInfo& get_info() override { return next->get_info(); }
virtual void print(std::ostream& out) const override { return next->print(out); }
/* Internal to Filters */
User* get_next() { return next.get(); }
};
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) {}
virtual ~FilterBucket() = default;
virtual std::unique_ptr<Object> get_object(const rgw_obj_key& key) override;
virtual int list(const DoutPrefixProvider* dpp, ListParams&, int,
ListResults&, optional_yield y) override;
virtual Attrs& get_attrs(void) override { return next->get_attrs(); }
virtual int set_attrs(Attrs a) override { return next->set_attrs(a); }
virtual int remove_bucket(const DoutPrefixProvider* dpp, bool delete_children,
bool forward_to_master, req_info* req_info,
optional_yield y) override;
virtual int remove_bucket_bypass_gc(int concurrent_max, bool
keep_index_consistent,
optional_yield y, const
DoutPrefixProvider *dpp) override;
virtual RGWAccessControlPolicy& get_acl(void) override { return next->get_acl(); }
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 load_bucket(const DoutPrefixProvider* dpp, optional_yield y,
bool get_stats = false) override;
virtual int read_stats(const DoutPrefixProvider *dpp,
const bucket_index_layout_generation& idx_layout,
int shard_id, std::string* bucket_ver, std::string* master_ver,
std::map<RGWObjCategory, RGWStorageStats>& stats,
std::string* max_marker = nullptr,
bool* syncstopped = nullptr) override;
virtual int read_stats_async(const DoutPrefixProvider *dpp,
const bucket_index_layout_generation& idx_layout,
int shard_id, RGWGetBucketStats_CB* ctx) override;
virtual int sync_user_stats(const DoutPrefixProvider *dpp, optional_yield y) override;
virtual int update_container_stats(const DoutPrefixProvider* dpp, optional_yield y) override;
virtual int check_bucket_shards(const DoutPrefixProvider* dpp, optional_yield y) override;
virtual int chown(const DoutPrefixProvider* dpp, User& new_user,
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 ACLOwner get_acl_owner(void) override { return next->get_acl_owner(); }
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 merge_and_store_attrs(const DoutPrefixProvider* dpp,
Attrs& new_attrs, optional_yield y) override;
virtual int try_refresh_info(const DoutPrefixProvider* dpp,
ceph::real_time* pmtime, optional_yield y) override;
virtual int read_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch,
uint64_t end_epoch, uint32_t max_entries,
bool* is_truncated, RGWUsageIter& usage_iter,
std::map<rgw_user_bucket,
rgw_usage_log_entry>& usage) override;
virtual int trim_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch,
uint64_t end_epoch, optional_yield y) override;
virtual int remove_objs_from_index(const DoutPrefixProvider *dpp,
std::list<rgw_obj_index_key>&
objs_to_unlink) override;
virtual int check_index(const DoutPrefixProvider *dpp,
std::map<RGWObjCategory, RGWStorageStats>&
existing_stats,
std::map<RGWObjCategory, RGWStorageStats>&
calculated_stats) override;
virtual int rebuild_index(const DoutPrefixProvider *dpp) override;
virtual int set_tag_timeout(const DoutPrefixProvider *dpp, uint64_t timeout) override;
virtual int purge_instance(const DoutPrefixProvider* dpp, optional_yield y) override;
virtual void set_count(uint64_t _count) override { return next->set_count(_count); }
virtual void set_size(uint64_t _size) override { return next->set_size(_size); }
virtual bool empty() const override { return next->empty(); }
virtual const std::string& get_name() const override { return next->get_name(); }
virtual const std::string& get_tenant() const override { return next->get_tenant(); }
virtual const std::string& get_marker() const override { return next->get_marker(); }
virtual const std::string& get_bucket_id() const override { return next->get_bucket_id(); }
virtual size_t get_size() const override { return next->get_size(); }
virtual size_t get_size_rounded() const override { return next->get_size_rounded(); }
virtual uint64_t get_count() const override { return next->get_count(); }
virtual rgw_placement_rule& get_placement_rule() override { return next->get_placement_rule(); }
virtual ceph::real_time& get_creation_time() override { return next->get_creation_time(); }
virtual ceph::real_time& get_modification_time() override { return next->get_modification_time(); }
virtual obj_version& get_version() override { return next->get_version(); }
virtual void set_version(obj_version &ver) override { next->set_version(ver); }
virtual bool versioned() override { return next->versioned(); }
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);
}
virtual std::unique_ptr<MultipartUpload> get_multipart_upload(
const std::string& oid,
std::optional<std::string> upload_id=std::nullopt,
ACLOwner owner={}, ceph::real_time mtime=real_clock::now()) override;
virtual int list_multiparts(const DoutPrefixProvider *dpp,
const std::string& prefix,
std::string& marker,
const std::string& delim,
const int& max_uploads,
std::vector<std::unique_ptr<MultipartUpload>>& uploads,
std::map<std::string, bool> *common_prefixes,
bool *is_truncated, optional_yield y) override;
virtual int abort_multiparts(const DoutPrefixProvider* dpp,
CephContext* cct, optional_yield y) override;
int read_topics(rgw_pubsub_bucket_topics& notifications, RGWObjVersionTracker* objv_tracker,
optional_yield y, const DoutPrefixProvider *dpp) override {
return next->read_topics(notifications, objv_tracker, y, dpp);
}
int write_topics(const rgw_pubsub_bucket_topics& notifications, RGWObjVersionTracker* obj_tracker,
optional_yield y, const DoutPrefixProvider *dpp) override {
return next->write_topics(notifications, obj_tracker, y, dpp);
}
int remove_topics(RGWObjVersionTracker* objv_tracker,
optional_yield y, const DoutPrefixProvider *dpp) override {
return next->remove_topics(objv_tracker, y, dpp);
}
virtual rgw_bucket& get_key() override { return next->get_key(); }
virtual RGWBucketInfo& get_info() override { return next->get_info(); }
virtual void print(std::ostream& out) const override { return next->print(out); }
virtual bool operator==(const Bucket& b) const override { return next->operator==(b); }
virtual bool operator!=(const Bucket& b) const override { return next->operator!=(b); }
friend class BucketList;
/* Internal to Filters */
Bucket* get_next() { return next.get(); }
};
class FilterObject : public Object {
protected:
std::unique_ptr<Object> next;
private:
Bucket* bucket{nullptr};
public:
struct FilterReadOp : ReadOp {
std::unique_ptr<ReadOp> next;
FilterReadOp(std::unique_ptr<ReadOp> _next) : next(std::move(_next)) {}
virtual ~FilterReadOp() = default;
virtual int prepare(optional_yield y, const DoutPrefixProvider* dpp) override;
virtual int read(int64_t ofs, int64_t end, bufferlist& bl, optional_yield y,
const DoutPrefixProvider* dpp) override;
virtual int iterate(const DoutPrefixProvider* dpp, int64_t ofs, int64_t end,
RGWGetDataCB* cb, optional_yield y) override;
virtual int get_attr(const DoutPrefixProvider* dpp, const char* name,
bufferlist& dest, optional_yield y) override;
};
struct FilterDeleteOp : DeleteOp {
std::unique_ptr<DeleteOp> next;
FilterDeleteOp(std::unique_ptr<DeleteOp> _next) : next(std::move(_next)) {}
virtual ~FilterDeleteOp() = default;
virtual int delete_obj(const DoutPrefixProvider* dpp, optional_yield y) override;
};
FilterObject(std::unique_ptr<Object> _next) : next(std::move(_next)) {}
FilterObject(std::unique_ptr<Object> _next, Bucket* _bucket) :
next(std::move(_next)), bucket(_bucket) {}
FilterObject(FilterObject& _o) {
next = _o.next->clone();
bucket = _o.bucket;
}
virtual ~FilterObject() = default;
virtual int delete_object(const DoutPrefixProvider* dpp,
optional_yield y,
bool prevent_versioning = false) override;
virtual int copy_object(User* user,
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,
const ceph::real_time* mod_ptr, const ceph::real_time* unmod_ptr,
bool high_precision_time,
const char* if_match, const char* if_nomatch,
AttrsMod attrs_mod, bool copy_if_newer, Attrs& attrs,
RGWObjCategory category, uint64_t olh_epoch,
boost::optional<ceph::real_time> delete_at,
std::string* version_id, std::string* tag, std::string* etag,
void (*progress_cb)(off_t, void *), void* progress_data,
const DoutPrefixProvider* dpp, optional_yield y) override;
virtual RGWAccessControlPolicy& get_acl(void) override;
virtual int set_acl(const RGWAccessControlPolicy& acl) override { return next->set_acl(acl); }
virtual void set_atomic() override { return next->set_atomic(); }
virtual bool is_atomic() override { return next->is_atomic(); }
virtual void set_prefetch_data() override { return next->set_prefetch_data(); }
virtual bool is_prefetch_data() override { return next->is_prefetch_data(); }
virtual void set_compressed() override { return next->set_compressed(); }
virtual bool is_compressed() override { return next->is_compressed(); }
virtual void invalidate() override { return next->invalidate(); }
virtual bool empty() const override { return next->empty(); }
virtual const std::string &get_name() const override { return next->get_name(); }
virtual int get_obj_state(const DoutPrefixProvider* dpp, RGWObjState **state,
optional_yield y, bool follow_olh = true) override;
virtual void set_obj_state(RGWObjState& _state) override { return next->set_obj_state(_state); }
virtual int set_obj_attrs(const DoutPrefixProvider* dpp, Attrs* setattrs,
Attrs* delattrs, optional_yield y) override;
virtual int get_obj_attrs(optional_yield y, const DoutPrefixProvider* dpp,
rgw_obj* target_obj = NULL) override;
virtual int modify_obj_attrs(const char* attr_name, bufferlist& attr_val,
optional_yield y, const DoutPrefixProvider* dpp) override;
virtual int delete_obj_attrs(const DoutPrefixProvider* dpp, const char* attr_name,
optional_yield y) override;
virtual bool is_expired() override;
virtual void gen_rand_obj_instance_name() override;
virtual std::unique_ptr<MPSerializer> get_serializer(const DoutPrefixProvider *dpp,
const std::string& lock_name) override;
virtual int transition(Bucket* bucket,
const rgw_placement_rule& placement_rule,
const real_time& mtime,
uint64_t olh_epoch,
const DoutPrefixProvider* dpp,
optional_yield y) override;
virtual int transition_to_cloud(Bucket* bucket,
rgw::sal::PlacementTier* tier,
rgw_bucket_dir_entry& o,
std::set<std::string>& cloud_targets,
CephContext* cct,
bool update_object,
const DoutPrefixProvider* dpp,
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 Attrs& get_attrs(void) override { return next->get_attrs(); };
virtual const Attrs& get_attrs(void) const override { return next->get_attrs(); };
virtual int set_attrs(Attrs a) override { return next->set_attrs(a); };
virtual bool has_attrs(void) override { return next->has_attrs(); };
virtual ceph::real_time get_mtime(void) const override { return next->get_mtime(); };
virtual uint64_t get_obj_size(void) const override { return next->get_obj_size(); };
virtual Bucket* get_bucket(void) const override { return bucket; };
virtual void set_bucket(Bucket* b) override;
virtual std::string get_hash_source(void) override { return next->get_hash_source(); };
virtual void set_hash_source(std::string s) override { return next->set_hash_source(s); };
virtual std::string get_oid(void) const override { return next->get_oid(); };
virtual bool get_delete_marker(void) override { return next->get_delete_marker(); };
virtual bool get_in_extra_data(void) override { return next->get_in_extra_data(); };
virtual void set_in_extra_data(bool i) override { return next->set_in_extra_data(i); };
int range_to_ofs(uint64_t obj_size, int64_t &ofs, int64_t &end) {
return next->range_to_ofs(obj_size, ofs, end);
};
virtual void set_obj_size(uint64_t s) override { return next->set_obj_size(s); };
virtual void set_name(const std::string& n) override { return next->set_name(n); };
virtual void set_key(const rgw_obj_key& k) override { return next->set_key(k); };
virtual rgw_obj get_obj(void) const override { return next->get_obj(); };
virtual rgw_obj_key& get_key() override { return next->get_key(); }
virtual void set_instance(const std::string &i) override { return next->set_instance(i); }
virtual const std::string &get_instance() const override { return next->get_instance(); }
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 */
const DoutPrefixProvider* dpp, optional_yield y) override;
virtual int swift_versioning_copy(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 int get_torrent_info(const DoutPrefixProvider* dpp,
optional_yield y, bufferlist& bl) override;
virtual int omap_get_vals_by_keys(const DoutPrefixProvider *dpp,
const std::string& oid,
const std::set<std::string>& keys,
Attrs* vals) override;
virtual int omap_set_val_by_key(const DoutPrefixProvider *dpp,
const std::string& key, bufferlist& val,
bool must_exist, optional_yield y) override;
virtual int chown(User& new_user, const DoutPrefixProvider* dpp,
optional_yield y) override;
virtual std::unique_ptr<Object> clone() override {
return std::make_unique<FilterObject>(*this);
}
virtual void print(std::ostream& out) const override { return next->print(out); }
/* Internal to Filters */
Object* get_next() { return next.get(); }
};
class FilterMultipartPart : public MultipartPart {
protected:
std::unique_ptr<MultipartPart> next;
public:
FilterMultipartPart(std::unique_ptr<MultipartPart> _next) : next(std::move(_next)) {}
virtual ~FilterMultipartPart() = default;
virtual uint32_t get_num() override { return next->get_num(); }
virtual uint64_t get_size() override { return next->get_size(); }
virtual const std::string& get_etag() override { return next->get_etag(); }
virtual ceph::real_time& get_mtime() override { return next->get_mtime(); }
};
class FilterMultipartUpload : public MultipartUpload {
protected:
std::unique_ptr<MultipartUpload> next;
Bucket* bucket;
std::map<uint32_t, std::unique_ptr<MultipartPart>> parts;
public:
FilterMultipartUpload(std::unique_ptr<MultipartUpload> _next, Bucket* _b) :
next(std::move(_next)), bucket(_b) {}
virtual ~FilterMultipartUpload() = default;
virtual const std::string& get_meta() const override { return next->get_meta(); }
virtual const std::string& get_key() const override { return next->get_key(); }
virtual const std::string& get_upload_id() const override { return next->get_upload_id(); }
virtual const ACLOwner& get_owner() const override { return next->get_owner(); }
virtual ceph::real_time& get_mtime() override { return next->get_mtime(); }
virtual std::map<uint32_t, std::unique_ptr<MultipartPart>>& get_parts() override { return parts; }
virtual const jspan_context& get_trace() override { return next->get_trace(); }
virtual std::unique_ptr<rgw::sal::Object> get_meta_obj() override;
virtual int init(const DoutPrefixProvider* dpp, optional_yield y, ACLOwner& owner, rgw_placement_rule& dest_placement, rgw::sal::Attrs& attrs) override;
virtual int list_parts(const DoutPrefixProvider* dpp, CephContext* cct,
int num_parts, int marker,
int* next_marker, bool* truncated, optional_yield y,
bool assume_unsorted = false) override;
virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct, optional_yield y) override;
virtual int complete(const DoutPrefixProvider* dpp,
optional_yield y, CephContext* cct,
std::map<int, std::string>& part_etags,
std::list<rgw_obj_index_key>& remove_objs,
uint64_t& accounted_size, bool& compressed,
RGWCompressionInfo& cs_info, off_t& ofs,
std::string& tag, ACLOwner& owner,
uint64_t olh_epoch,
rgw::sal::Object* target_obj) override;
virtual int get_info(const DoutPrefixProvider *dpp, optional_yield y,
rgw_placement_rule** rule,
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,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num,
const std::string& part_num_str) override;
virtual void print(std::ostream& out) const override { return next->print(out); }
};
class FilterMPSerializer : public MPSerializer {
protected:
std::unique_ptr<MPSerializer> next;
public:
FilterMPSerializer(std::unique_ptr<MPSerializer> _next) : next(std::move(_next)) {}
virtual ~FilterMPSerializer() = default;
virtual int try_lock(const DoutPrefixProvider *dpp, utime_t dur, optional_yield y) override;
virtual int unlock() override { return next->unlock(); }
virtual void clear_locked() override { next->clear_locked(); }
virtual bool is_locked() override { return next->is_locked(); }
virtual void print(std::ostream& out) const override { return next->print(out); }
};
class FilterLCSerializer : public LCSerializer {
protected:
std::unique_ptr<LCSerializer> next;
public:
FilterLCSerializer(std::unique_ptr<LCSerializer> _next) : next(std::move(_next)) {}
virtual ~FilterLCSerializer() = default;
virtual int try_lock(const DoutPrefixProvider *dpp, utime_t dur, optional_yield y) override;
virtual int unlock() override { return next->unlock(); }
virtual void print(std::ostream& out) const override { return next->print(out); }
};
class FilterLifecycle : public Lifecycle {
protected:
std::unique_ptr<Lifecycle> next;
public:
struct FilterLCHead : LCHead {
std::unique_ptr<LCHead> next;
FilterLCHead(std::unique_ptr<LCHead> _next) : next(std::move(_next)) {}
virtual ~FilterLCHead() = default;
virtual time_t& get_start_date() override { return next->get_start_date(); }
virtual void set_start_date(time_t t) override { next->set_start_date(t); }
virtual std::string& get_marker() override { return next->get_marker(); }
virtual void set_marker(const std::string& m) override { next->set_marker(m); }
virtual time_t& get_shard_rollover_date() override { return next->get_shard_rollover_date(); }
virtual void set_shard_rollover_date(time_t t) override { next->set_shard_rollover_date(t); }
};
struct FilterLCEntry : LCEntry {
std::unique_ptr<LCEntry> next;
FilterLCEntry(std::unique_ptr<LCEntry> _next) : next(std::move(_next)) {}
virtual ~FilterLCEntry() = default;
virtual std::string& get_bucket() override { return next->get_bucket(); }
virtual void set_bucket(const std::string& b) override { next->set_bucket(b); }
virtual std::string& get_oid() override { return next->get_oid(); }
virtual void set_oid(const std::string& o) override { next->set_oid(o); }
virtual uint64_t get_start_time() override { return next->get_start_time(); }
virtual void set_start_time(uint64_t t) override { next->set_start_time(t); }
virtual uint32_t get_status() override { return next->get_status(); }
virtual void set_status(uint32_t s) override { next->set_status(s); }
virtual void print(std::ostream& out) const override { return next->print(out); }
};
FilterLifecycle(std::unique_ptr<Lifecycle> _next) : next(std::move(_next)) {}
virtual ~FilterLifecycle() = default;
virtual std::unique_ptr<LCEntry> get_entry() override;
virtual int get_entry(const std::string& oid, const std::string& marker,
std::unique_ptr<LCEntry>* entry) override;
virtual int get_next_entry(const std::string& oid, const std::string& marker,
std::unique_ptr<LCEntry>* entry) override;
virtual int set_entry(const std::string& oid, LCEntry& entry) override;
virtual int list_entries(const std::string& oid, const std::string& marker,
uint32_t max_entries,
std::vector<std::unique_ptr<LCEntry>>& entries) override;
virtual int rm_entry(const std::string& oid, LCEntry& entry) override;
virtual int get_head(const std::string& oid, std::unique_ptr<LCHead>* head) override;
virtual int put_head(const std::string& oid, LCHead& head) override;
virtual std::unique_ptr<LCSerializer> get_serializer(const std::string& lock_name,
const std::string& oid,
const std::string& cookie) override;
};
class FilterNotification : public Notification {
protected:
std::unique_ptr<Notification> next;
public:
FilterNotification(std::unique_ptr<Notification> _next) : next(std::move(_next)) {}
virtual ~FilterNotification() = default;
virtual int publish_reserve(const DoutPrefixProvider *dpp,
RGWObjTags* obj_tags = nullptr) override;
virtual int publish_commit(const DoutPrefixProvider* dpp, uint64_t size,
const ceph::real_time& mtime,
const std::string& etag,
const std::string& version) override;
};
class FilterWriter : public Writer {
protected:
std::unique_ptr<Writer> next;
Object* obj;
public:
FilterWriter(std::unique_ptr<Writer> _next, Object* _obj) :
next(std::move(_next)), obj(_obj) {}
virtual ~FilterWriter() = default;
virtual int prepare(optional_yield y) { return next->prepare(y); }
virtual int process(bufferlist&& data, uint64_t offset) override;
virtual int complete(size_t accounted_size, const std::string& etag,
ceph::real_time *mtime, ceph::real_time set_mtime,
std::map<std::string, bufferlist>& attrs,
ceph::real_time delete_at,
const char *if_match, const char *if_nomatch,
const std::string *user_data,
rgw_zone_set *zones_trace, bool *canceled,
optional_yield y) override;
};
class FilterLuaManager : public LuaManager {
protected:
std::unique_ptr<LuaManager> next;
public:
FilterLuaManager(std::unique_ptr<LuaManager> _next) : next(std::move(_next)) {}
virtual ~FilterLuaManager() = default;
virtual int get_script(const DoutPrefixProvider* dpp, optional_yield y, const std::string& key, std::string& script) override;
virtual int put_script(const DoutPrefixProvider* dpp, optional_yield y, const std::string& key, const std::string& script) override;
virtual int del_script(const DoutPrefixProvider* dpp, optional_yield y, const std::string& key) override;
virtual int add_package(const DoutPrefixProvider* dpp, optional_yield y, const std::string& package_name) override;
virtual int remove_package(const DoutPrefixProvider* dpp, optional_yield y, const std::string& package_name) override;
virtual int list_packages(const DoutPrefixProvider* dpp, optional_yield y, rgw::lua::packages_t& packages) override;
};
} } // namespace rgw::sal
| 42,650 | 46.024256 | 154 |
h
|
null |
ceph-main/src/rgw/rgw_sal_fwd.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2022 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#pragma once
namespace rgw { namespace sal {
class Driver;
class User;
class Bucket;
class BucketList;
class Object;
class MultipartUpload;
class Lifecycle;
class Notification;
class Writer;
class PlacementTier;
class ZoneGroup;
class Zone;
class LuaManager;
struct RGWRoleInfo;
class ConfigStore;
class RealmWriter;
class ZoneGroupWriter;
class ZoneWriter;
} } // namespace rgw::sal
| 837 | 18.952381 | 70 |
h
|
null |
ceph-main/src/rgw/rgw_sal_motr.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=2 sw=2 expandtab ft=cpp
/*
* Ceph - scalable distributed file system
*
* SAL implementation for the CORTX Motr backend
*
* Copyright (C) 2021 Seagate Technology LLC and/or its Affiliates
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
extern "C" {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wextern-c-compat"
#pragma clang diagnostic ignored "-Wdeprecated-anon-enum-enum-conversion"
#include "motr/config.h"
#include "lib/types.h"
#include "lib/trace.h" // m0_trace_set_mmapped_buffer
#include "motr/layout.h" // M0_OBJ_LAYOUT_ID
#include "helpers/helpers.h" // m0_ufid_next
#pragma clang diagnostic pop
}
#include "common/Clock.h"
#include "common/errno.h"
#include "rgw_compression.h"
#include "rgw_sal.h"
#include "rgw_sal_motr.h"
#include "rgw_bucket.h"
#define dout_subsys ceph_subsys_rgw
using std::string;
using std::map;
using std::vector;
using std::set;
using std::list;
static string mp_ns = RGW_OBJ_NS_MULTIPART;
static struct m0_ufid_generator ufid_gr;
namespace rgw::sal {
using ::ceph::encode;
using ::ceph::decode;
static std::string motr_global_indices[] = {
RGW_MOTR_USERS_IDX_NAME,
RGW_MOTR_BUCKET_INST_IDX_NAME,
RGW_MOTR_BUCKET_HD_IDX_NAME,
RGW_IAM_MOTR_ACCESS_KEY,
RGW_IAM_MOTR_EMAIL_KEY
};
void MotrMetaCache::invalid(const DoutPrefixProvider *dpp,
const string& name)
{
cache.invalidate_remove(dpp, name);
}
int MotrMetaCache::put(const DoutPrefixProvider *dpp,
const string& name,
const bufferlist& data)
{
ldpp_dout(dpp, 0) << "Put into cache: name = " << name << dendl;
ObjectCacheInfo info;
info.status = 0;
info.data = data;
info.flags = CACHE_FLAG_DATA;
info.meta.mtime = ceph::real_clock::now();
info.meta.size = data.length();
cache.put(dpp, name, info, NULL);
// Inform other rgw instances. Do nothing if it gets some error?
int rc = distribute_cache(dpp, name, info, UPDATE_OBJ);
if (rc < 0)
ldpp_dout(dpp, 0) << "ERROR: failed to distribute cache for " << name << dendl;
return 0;
}
int MotrMetaCache::get(const DoutPrefixProvider *dpp,
const string& name,
bufferlist& data)
{
ObjectCacheInfo info;
uint32_t flags = CACHE_FLAG_DATA;
int rc = cache.get(dpp, name, info, flags, NULL);
if (rc == 0) {
if (info.status < 0)
return info.status;
bufferlist& bl = info.data;
bufferlist::iterator it = bl.begin();
data.clear();
it.copy_all(data);
ldpp_dout(dpp, 0) << "Cache hit: name = " << name << dendl;
return 0;
}
ldpp_dout(dpp, 0) << "Cache miss: name = " << name << ", rc = "<< rc << dendl;
if(rc == -ENODATA)
return -ENOENT;
return rc;
}
int MotrMetaCache::remove(const DoutPrefixProvider *dpp,
const string& name)
{
cache.invalidate_remove(dpp, name);
ObjectCacheInfo info;
int rc = distribute_cache(dpp, name, info, INVALIDATE_OBJ);
if (rc < 0) {
ldpp_dout(dpp, 0) << "ERROR: " <<__func__<< "(): failed to distribute cache: rc =" << rc << dendl;
}
ldpp_dout(dpp, 0) << "Remove from cache: name = " << name << dendl;
return 0;
}
int MotrMetaCache::distribute_cache(const DoutPrefixProvider *dpp,
const string& normal_name,
ObjectCacheInfo& obj_info, int op)
{
return 0;
}
int MotrMetaCache::watch_cb(const DoutPrefixProvider *dpp,
uint64_t notify_id,
uint64_t cookie,
uint64_t notifier_id,
bufferlist& bl)
{
return 0;
}
void MotrMetaCache::set_enabled(bool status)
{
cache.set_enabled(status);
}
// TODO: properly handle the number of key/value pairs to get in
// one query. Now the POC simply tries to retrieve all `max` number of pairs
// with starting key `marker`.
int MotrUser::list_buckets(const DoutPrefixProvider *dpp, const string& marker,
const string& end_marker, uint64_t max, bool need_stats,
BucketList &buckets, optional_yield y)
{
int rc;
vector<string> keys(max);
vector<bufferlist> vals(max);
bool is_truncated = false;
ldpp_dout(dpp, 20) <<__func__<< ": list_user_buckets: marker=" << marker
<< " end_marker=" << end_marker
<< " max=" << max << dendl;
// Retrieve all `max` number of pairs.
buckets.clear();
string user_info_iname = "motr.rgw.user.info." + info.user_id.to_str();
keys[0] = marker;
rc = store->next_query_by_name(user_info_iname, keys, vals);
if (rc < 0) {
ldpp_dout(dpp, 0) << "ERROR: NEXT query failed. " << rc << dendl;
return rc;
}
// Process the returned pairs to add into BucketList.
uint64_t bcount = 0;
for (const auto& bl: vals) {
if (bl.length() == 0)
break;
RGWBucketEnt ent;
auto iter = bl.cbegin();
ent.decode(iter);
std::time_t ctime = ceph::real_clock::to_time_t(ent.creation_time);
ldpp_dout(dpp, 20) << "got creation time: << " << std::put_time(std::localtime(&ctime), "%F %T") << dendl;
if (!end_marker.empty() &&
end_marker.compare(ent.bucket.marker) <= 0)
break;
buckets.add(std::make_unique<MotrBucket>(this->store, ent, this));
bcount++;
}
if (bcount == max)
is_truncated = true;
buckets.set_truncated(is_truncated);
return 0;
}
int MotrUser::create_bucket(const DoutPrefixProvider* dpp,
const rgw_bucket& b,
const std::string& zonegroup_id,
rgw_placement_rule& placement_rule,
std::string& swift_ver_location,
const RGWQuotaInfo* pquota_info,
const RGWAccessControlPolicy& policy,
Attrs& attrs,
RGWBucketInfo& info,
obj_version& ep_objv,
bool exclusive,
bool obj_lock_enabled,
bool* existed,
req_info& req_info,
std::unique_ptr<Bucket>* bucket_out,
optional_yield y)
{
int ret;
std::unique_ptr<Bucket> bucket;
// Look up the bucket. Create it if it doesn't exist.
ret = this->store->get_bucket(dpp, this, b, &bucket, y);
if (ret < 0 && ret != -ENOENT)
return ret;
if (ret != -ENOENT) {
*existed = true;
// if (swift_ver_location.empty()) {
// swift_ver_location = bucket->get_info().swift_ver_location;
// }
// placement_rule.inherit_from(bucket->get_info().placement_rule);
// TODO: ACL policy
// // don't allow changes to the acl policy
//RGWAccessControlPolicy old_policy(ctx());
//int rc = rgw_op_get_bucket_policy_from_attr(
// dpp, this, u, bucket->get_attrs(), &old_policy, y);
//if (rc >= 0 && old_policy != policy) {
// bucket_out->swap(bucket);
// return -EEXIST;
//}
} else {
placement_rule.name = "default";
placement_rule.storage_class = "STANDARD";
bucket = std::make_unique<MotrBucket>(store, b, this);
bucket->set_attrs(attrs);
*existed = false;
}
if (!*existed){
// TODO: how to handle zone and multi-site.
info.placement_rule = placement_rule;
info.bucket = b;
info.owner = this->get_info().user_id;
info.zonegroup = zonegroup_id;
if (obj_lock_enabled)
info.flags = BUCKET_VERSIONED | BUCKET_OBJ_LOCK_ENABLED;
bucket->set_version(ep_objv);
bucket->get_info() = info;
// Create a new bucket: (1) Add a key/value pair in the
// bucket instance index. (2) Create a new bucket index.
MotrBucket* mbucket = static_cast<MotrBucket*>(bucket.get());
ret = mbucket->put_info(dpp, y, ceph::real_time())? :
mbucket->create_bucket_index() ? :
mbucket->create_multipart_indices();
if (ret < 0)
ldpp_dout(dpp, 0) << "ERROR: failed to create bucket indices! " << ret << dendl;
// Insert the bucket entry into the user info index.
ret = mbucket->link_user(dpp, this, y);
if (ret < 0)
ldpp_dout(dpp, 0) << "ERROR: failed to add bucket entry! " << ret << dendl;
} else {
return -EEXIST;
// bucket->set_version(ep_objv);
// bucket->get_info() = info;
}
bucket_out->swap(bucket);
return ret;
}
int MotrUser::read_attrs(const DoutPrefixProvider* dpp, optional_yield y)
{
return 0;
}
int MotrUser::read_stats(const DoutPrefixProvider *dpp,
optional_yield y, RGWStorageStats* stats,
ceph::real_time *last_stats_sync,
ceph::real_time *last_stats_update)
{
return 0;
}
/* stats - Not for first pass */
int MotrUser::read_stats_async(const DoutPrefixProvider *dpp, RGWGetUserStats_CB *cb)
{
return 0;
}
int MotrUser::complete_flush_stats(const DoutPrefixProvider *dpp, optional_yield y)
{
return 0;
}
int MotrUser::read_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch, uint32_t max_entries,
bool *is_truncated, RGWUsageIter& usage_iter,
map<rgw_user_bucket, rgw_usage_log_entry>& usage)
{
return 0;
}
int MotrUser::trim_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch)
{
return 0;
}
int MotrUser::load_user_from_idx(const DoutPrefixProvider *dpp,
MotrStore *store,
RGWUserInfo& info, map<string, bufferlist> *attrs,
RGWObjVersionTracker *objv_tr)
{
struct MotrUserInfo muinfo;
bufferlist bl;
ldpp_dout(dpp, 20) << "info.user_id.id = " << info.user_id.id << dendl;
if (store->get_user_cache()->get(dpp, info.user_id.id, bl)) {
// Cache misses
int rc = store->do_idx_op_by_name(RGW_MOTR_USERS_IDX_NAME,
M0_IC_GET, info.user_id.to_str(), bl);
ldpp_dout(dpp, 20) << "do_idx_op_by_name() = " << rc << dendl;
if (rc < 0)
return rc;
// Put into cache.
store->get_user_cache()->put(dpp, info.user_id.id, bl);
}
bufferlist& blr = bl;
auto iter = blr.cbegin();
muinfo.decode(iter);
info = muinfo.info;
if (attrs)
*attrs = muinfo.attrs;
if (objv_tr)
{
objv_tr->read_version = muinfo.user_version;
objv_tracker.read_version = objv_tr->read_version;
}
if (!info.access_keys.empty()) {
for(auto key : info.access_keys) {
access_key_tracker.insert(key.first);
}
}
return 0;
}
int MotrUser::load_user(const DoutPrefixProvider *dpp,
optional_yield y)
{
ldpp_dout(dpp, 20) << "load user: user id = " << info.user_id.to_str() << dendl;
return load_user_from_idx(dpp, store, info, &attrs, &objv_tracker);
}
int MotrUser::create_user_info_idx()
{
string user_info_iname = "motr.rgw.user.info." + info.user_id.to_str();
return store->create_motr_idx_by_name(user_info_iname);
}
int MotrUser::merge_and_store_attrs(const DoutPrefixProvider* dpp, Attrs& new_attrs, optional_yield y)
{
for (auto& it : new_attrs)
attrs[it.first] = it.second;
return store_user(dpp, y, false);
}
int MotrUser::store_user(const DoutPrefixProvider* dpp,
optional_yield y, bool exclusive, RGWUserInfo* old_info)
{
bufferlist bl;
struct MotrUserInfo muinfo;
RGWUserInfo orig_info;
RGWObjVersionTracker objv_tr = {};
obj_version& obj_ver = objv_tr.read_version;
ldpp_dout(dpp, 20) << "Store_user(): User = " << info.user_id.id << dendl;
orig_info.user_id = info.user_id;
// XXX: we open and close motr idx 2 times in this method:
// 1) on load_user_from_idx() here and 2) on do_idx_op_by_name(PUT) below.
// Maybe this can be optimised later somewhow.
int rc = load_user_from_idx(dpp, store, orig_info, nullptr, &objv_tr);
ldpp_dout(dpp, 10) << "Get user: rc = " << rc << dendl;
// Check if the user already exists
if (rc == 0 && obj_ver.ver > 0) {
if (old_info)
*old_info = orig_info;
if (obj_ver.ver != objv_tracker.read_version.ver) {
rc = -ECANCELED;
ldpp_dout(dpp, 0) << "ERROR: User Read version mismatch" << dendl;
goto out;
}
if (exclusive)
return rc;
obj_ver.ver++;
} else {
obj_ver.ver = 1;
obj_ver.tag = "UserTAG";
}
// Insert the user to user info index.
muinfo.info = info;
muinfo.attrs = attrs;
muinfo.user_version = obj_ver;
muinfo.encode(bl);
rc = store->do_idx_op_by_name(RGW_MOTR_USERS_IDX_NAME,
M0_IC_PUT, info.user_id.to_str(), bl);
ldpp_dout(dpp, 10) << "Store user to motr index: rc = " << rc << dendl;
if (rc == 0) {
objv_tracker.read_version = obj_ver;
objv_tracker.write_version = obj_ver;
}
// Store access key in access key index
if (!info.access_keys.empty()) {
std::string access_key;
std::string secret_key;
std::map<std::string, RGWAccessKey>::const_iterator iter = info.access_keys.begin();
const RGWAccessKey& k = iter->second;
access_key = k.id;
secret_key = k.key;
MotrAccessKey MGWUserKeys(access_key, secret_key, info.user_id.to_str());
store->store_access_key(dpp, y, MGWUserKeys);
access_key_tracker.insert(access_key);
}
// Check if any key need to be deleted
if (access_key_tracker.size() != info.access_keys.size()) {
std::string key_for_deletion;
for (auto key : access_key_tracker) {
if (!info.get_key(key)) {
key_for_deletion = key;
ldpp_dout(dpp, 0) << "Deleting access key: " << key_for_deletion << dendl;
store->delete_access_key(dpp, y, key_for_deletion);
if (rc < 0) {
ldpp_dout(dpp, 0) << "Unable to delete access key" << rc << dendl;
}
}
}
if(rc >= 0){
access_key_tracker.erase(key_for_deletion);
}
}
if (!info.user_email.empty()) {
MotrEmailInfo MGWEmailInfo(info.user_id.to_str(), info.user_email);
store->store_email_info(dpp, y, MGWEmailInfo);
}
// Create user info index to store all buckets that are belong
// to this bucket.
rc = create_user_info_idx();
if (rc < 0 && rc != -EEXIST) {
ldpp_dout(dpp, 0) << "Failed to create user info index: rc = " << rc << dendl;
goto out;
}
// Put the user info into cache.
rc = store->get_user_cache()->put(dpp, info.user_id.id, bl);
out:
return rc;
}
int MotrUser::remove_user(const DoutPrefixProvider* dpp, optional_yield y)
{
// Remove user info from cache
// Delete access keys for user
// Delete user info
// Delete user from user index
// Delete email for user - TODO
bufferlist bl;
int rc;
// Remove the user info from cache.
store->get_user_cache()->remove(dpp, info.user_id.id);
// Delete all access key of user
if (!info.access_keys.empty()) {
for(auto acc_key = info.access_keys.begin(); acc_key != info.access_keys.end(); acc_key++) {
auto access_key = acc_key->first;
rc = store->delete_access_key(dpp, y, access_key);
// TODO
// Check error code for access_key does not exist
// Continue to next step only if delete failed because key doesn't exists
if (rc < 0){
ldpp_dout(dpp, 0) << "Unable to delete access key" << rc << dendl;
}
}
}
//Delete email id
if (!info.user_email.empty()) {
rc = store->do_idx_op_by_name(RGW_IAM_MOTR_EMAIL_KEY,
M0_IC_DEL, info.user_email, bl);
if (rc < 0 && rc != -ENOENT) {
ldpp_dout(dpp, 0) << "Unable to delete email id " << rc << dendl;
}
}
// Delete user info index
string user_info_iname = "motr.rgw.user.info." + info.user_id.to_str();
store->delete_motr_idx_by_name(user_info_iname);
ldpp_dout(dpp, 10) << "Deleted user info index - " << user_info_iname << dendl;
// Delete user from user index
rc = store->do_idx_op_by_name(RGW_MOTR_USERS_IDX_NAME,
M0_IC_DEL, info.user_id.to_str(), bl);
if (rc < 0){
ldpp_dout(dpp, 0) << "Unable to delete user from user index " << rc << dendl;
return rc;
}
// TODO
// Delete email for user
// rc = store->do_idx_op_by_name(RGW_IAM_MOTR_EMAIL_KEY,
// M0_IC_DEL, info.user_email, bl);
// if (rc < 0){
// ldpp_dout(dpp, 0) << "Unable to delete email for user" << rc << dendl;
// return rc;
// }
return 0;
}
int MotrUser::verify_mfa(const std::string& mfa_str, bool* verified, const DoutPrefixProvider *dpp, optional_yield y)
{
*verified = false;
return 0;
}
int MotrBucket::remove_bucket(const DoutPrefixProvider *dpp, bool delete_children, bool forward_to_master, req_info* req_info, optional_yield y)
{
int ret;
ldpp_dout(dpp, 20) << "remove_bucket Entry=" << info.bucket.name << dendl;
// Refresh info
ret = load_bucket(dpp, y);
if (ret < 0) {
ldpp_dout(dpp, 0) << "ERROR: remove_bucket load_bucket failed rc=" << ret << dendl;
return ret;
}
ListParams params;
params.list_versions = true;
params.allow_unordered = true;
ListResults results;
// 1. Check if Bucket has objects.
// If bucket contains objects and delete_children is true, delete all objects.
// Else throw error that bucket is not empty.
do {
results.objs.clear();
// Check if bucket has objects.
ret = list(dpp, params, 1000, results, y);
if (ret < 0) {
return ret;
}
// If result contains entries, bucket is not empty.
if (!results.objs.empty() && !delete_children) {
ldpp_dout(dpp, 0) << "ERROR: could not remove non-empty bucket " << info.bucket.name << dendl;
return -ENOTEMPTY;
}
for (const auto& obj : results.objs) {
rgw_obj_key key(obj.key);
/* xxx dang */
ret = rgw_remove_object(dpp, store, this, key);
if (ret < 0 && ret != -ENOENT) {
ldpp_dout(dpp, 0) << "ERROR: remove_bucket rgw_remove_object failed rc=" << ret << dendl;
return ret;
}
}
} while(results.is_truncated);
// 2. Abort Mp uploads on the bucket.
ret = abort_multiparts(dpp, store->ctx());
if (ret < 0) {
return ret;
}
// 3. Remove mp index??
string bucket_multipart_iname = "motr.rgw.bucket." + info.bucket.name + ".multiparts";
ret = store->delete_motr_idx_by_name(bucket_multipart_iname);
if (ret < 0) {
ldpp_dout(dpp, 0) << "ERROR: remove_bucket failed to remove multipart index rc=" << ret << dendl;
return ret;
}
// 4. Sync user stats.
ret = this->sync_user_stats(dpp, y);
if (ret < 0) {
ldout(store->ctx(), 1) << "WARNING: failed sync user stats before bucket delete. ret=" << ret << dendl;
}
// 5. Remove the bucket from user info index. (unlink user)
ret = this->unlink_user(dpp, owner, y);
if (ret < 0) {
ldpp_dout(dpp, 0) << "ERROR: remove_bucket unlink_user failed rc=" << ret << dendl;
return ret;
}
// 6. Remove bucket index.
string bucket_index_iname = "motr.rgw.bucket.index." + info.bucket.name;
ret = store->delete_motr_idx_by_name(bucket_index_iname);
if (ret < 0) {
ldpp_dout(dpp, 0) << "ERROR: remove_bucket unlink_user failed rc=" << ret << dendl;
return ret;
}
// 7. Remove bucket instance info.
bufferlist bl;
ret = store->get_bucket_inst_cache()->remove(dpp, info.bucket.name);
if (ret < 0) {
ldpp_dout(dpp, 0) << "ERROR: remove_bucket failed to remove bucket instance from cache rc="
<< ret << dendl;
return ret;
}
ret = store->do_idx_op_by_name(RGW_MOTR_BUCKET_INST_IDX_NAME,
M0_IC_DEL, info.bucket.name, bl);
if (ret < 0) {
ldpp_dout(dpp, 0) << "ERROR: remove_bucket failed to remove bucket instance rc="
<< ret << dendl;
return ret;
}
// TODO :
// 8. Remove Notifications
// if bucket has notification definitions associated with it
// they should be removed (note that any pending notifications on the bucket are still going to be sent)
// 9. Forward request to master.
if (forward_to_master) {
bufferlist in_data;
ret = store->forward_request_to_master(dpp, owner, &bucket_version, in_data, nullptr, *req_info, y);
if (ret < 0) {
if (ret == -ENOENT) {
/* adjust error, we want to return with NoSuchBucket and not
* NoSuchKey */
ret = -ERR_NO_SUCH_BUCKET;
}
ldpp_dout(dpp, 0) << "ERROR: Forward to master failed. ret=" << ret << dendl;
return ret;
}
}
ldpp_dout(dpp, 20) << "remove_bucket Exit=" << info.bucket.name << dendl;
return ret;
}
int MotrBucket::remove_bucket_bypass_gc(int concurrent_max, bool
keep_index_consistent,
optional_yield y, const
DoutPrefixProvider *dpp) {
return 0;
}
int MotrBucket::put_info(const DoutPrefixProvider *dpp, bool exclusive, ceph::real_time _mtime)
{
bufferlist bl;
struct MotrBucketInfo mbinfo;
ldpp_dout(dpp, 20) << "put_info(): bucket_id=" << info.bucket.bucket_id << dendl;
mbinfo.info = info;
mbinfo.bucket_attrs = attrs;
mbinfo.mtime = _mtime;
mbinfo.bucket_version = bucket_version;
mbinfo.encode(bl);
// Insert bucket instance using bucket's marker (string).
int rc = store->do_idx_op_by_name(RGW_MOTR_BUCKET_INST_IDX_NAME,
M0_IC_PUT, info.bucket.name, bl, !exclusive);
if (rc == 0)
store->get_bucket_inst_cache()->put(dpp, info.bucket.name, bl);
return rc;
}
int MotrBucket::load_bucket(const DoutPrefixProvider *dpp, optional_yield y, bool get_stats)
{
// Get bucket instance using bucket's name (string). or bucket id?
bufferlist bl;
if (store->get_bucket_inst_cache()->get(dpp, info.bucket.name, bl)) {
// Cache misses.
ldpp_dout(dpp, 20) << "load_bucket(): name=" << info.bucket.name << dendl;
int rc = store->do_idx_op_by_name(RGW_MOTR_BUCKET_INST_IDX_NAME,
M0_IC_GET, info.bucket.name, bl);
ldpp_dout(dpp, 20) << "load_bucket(): rc=" << rc << dendl;
if (rc < 0)
return rc;
store->get_bucket_inst_cache()->put(dpp, info.bucket.name, bl);
}
struct MotrBucketInfo mbinfo;
bufferlist& blr = bl;
auto iter =blr.cbegin();
mbinfo.decode(iter); //Decode into MotrBucketInfo.
info = mbinfo.info;
ldpp_dout(dpp, 20) << "load_bucket(): bucket_id=" << info.bucket.bucket_id << dendl;
rgw_placement_rule placement_rule;
placement_rule.name = "default";
placement_rule.storage_class = "STANDARD";
info.placement_rule = placement_rule;
attrs = mbinfo.bucket_attrs;
mtime = mbinfo.mtime;
bucket_version = mbinfo.bucket_version;
return 0;
}
int MotrBucket::link_user(const DoutPrefixProvider* dpp, User* new_user, optional_yield y)
{
bufferlist bl;
RGWBucketEnt new_bucket;
ceph::real_time creation_time = get_creation_time();
// RGWBucketEnt or cls_user_bucket_entry is the structure that is stored.
new_bucket.bucket = info.bucket;
new_bucket.size = 0;
if (real_clock::is_zero(creation_time))
creation_time = ceph::real_clock::now();
new_bucket.creation_time = creation_time;
new_bucket.encode(bl);
std::time_t ctime = ceph::real_clock::to_time_t(new_bucket.creation_time);
ldpp_dout(dpp, 20) << "got creation time: << " << std::put_time(std::localtime(&ctime), "%F %T") << dendl;
// Insert the user into the user info index.
string user_info_idx_name = "motr.rgw.user.info." + new_user->get_info().user_id.to_str();
return store->do_idx_op_by_name(user_info_idx_name,
M0_IC_PUT, info.bucket.name, bl);
}
int MotrBucket::unlink_user(const DoutPrefixProvider* dpp, User* new_user, optional_yield y)
{
// Remove the user into the user info index.
bufferlist bl;
string user_info_idx_name = "motr.rgw.user.info." + new_user->get_info().user_id.to_str();
return store->do_idx_op_by_name(user_info_idx_name,
M0_IC_DEL, info.bucket.name, bl);
}
/* stats - Not for first pass */
int MotrBucket::read_stats(const DoutPrefixProvider *dpp,
const bucket_index_layout_generation& idx_layout, int shard_id,
std::string *bucket_ver, std::string *master_ver,
std::map<RGWObjCategory, RGWStorageStats>& stats,
std::string *max_marker, bool *syncstopped)
{
return 0;
}
int MotrBucket::create_bucket_index()
{
string bucket_index_iname = "motr.rgw.bucket.index." + info.bucket.name;
return store->create_motr_idx_by_name(bucket_index_iname);
}
int MotrBucket::create_multipart_indices()
{
int rc;
// Bucket multipart index stores in-progress multipart uploads.
// Key is the object name + upload_id, value is a rgw_bucket_dir_entry.
// An entry is inserted when a multipart upload is initialised (
// MotrMultipartUpload::init()) and will be removed when the upload
// is completed (MotrMultipartUpload::complete()).
// MotrBucket::list_multiparts() will scan this index to return all
// in-progress multipart uploads in the bucket.
string bucket_multipart_iname = "motr.rgw.bucket." + info.bucket.name + ".multiparts";
rc = store->create_motr_idx_by_name(bucket_multipart_iname);
if (rc < 0) {
ldout(store->cctx, 0) << "Failed to create bucket multipart index " << bucket_multipart_iname << dendl;
return rc;
}
return 0;
}
int MotrBucket::read_stats_async(const DoutPrefixProvider *dpp,
const bucket_index_layout_generation& idx_layout,
int shard_id, RGWGetBucketStats_CB *ctx)
{
return 0;
}
int MotrBucket::sync_user_stats(const DoutPrefixProvider *dpp, optional_yield y)
{
return 0;
}
int MotrBucket::update_container_stats(const DoutPrefixProvider *dpp)
{
return 0;
}
int MotrBucket::check_bucket_shards(const DoutPrefixProvider *dpp)
{
return 0;
}
int MotrBucket::chown(const DoutPrefixProvider *dpp, User& new_user, optional_yield y)
{
// TODO: update bucket with new owner
return 0;
}
/* Make sure to call load_bucket() if you need it first */
bool MotrBucket::is_owner(User* user)
{
return (info.owner.compare(user->get_id()) == 0);
}
int MotrBucket::check_empty(const DoutPrefixProvider *dpp, optional_yield y)
{
/* XXX: Check if bucket contains any objects */
return 0;
}
int MotrBucket::check_quota(const DoutPrefixProvider *dpp, RGWQuota& quota, uint64_t obj_size,
optional_yield y, bool check_size_only)
{
/* Not Handled in the first pass as stats are also needed */
return 0;
}
int MotrBucket::merge_and_store_attrs(const DoutPrefixProvider *dpp, Attrs& new_attrs, optional_yield y)
{
for (auto& it : new_attrs)
attrs[it.first] = it.second;
return put_info(dpp, y, ceph::real_time());
}
int MotrBucket::try_refresh_info(const DoutPrefixProvider *dpp, ceph::real_time *pmtime)
{
return 0;
}
/* XXX: usage and stats not supported in the first pass */
int MotrBucket::read_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch,
uint32_t max_entries, bool *is_truncated,
RGWUsageIter& usage_iter,
map<rgw_user_bucket, rgw_usage_log_entry>& usage)
{
return 0;
}
int MotrBucket::trim_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch)
{
return 0;
}
int MotrBucket::remove_objs_from_index(const DoutPrefixProvider *dpp, std::list<rgw_obj_index_key>& objs_to_unlink)
{
/* XXX: CHECK: Unlike RadosStore, there is no seperate bucket index table.
* Delete all the object in the list from the object table of this
* bucket
*/
return 0;
}
int MotrBucket::check_index(const DoutPrefixProvider *dpp, std::map<RGWObjCategory, RGWStorageStats>& existing_stats, std::map<RGWObjCategory, RGWStorageStats>& calculated_stats)
{
/* XXX: stats not supported yet */
return 0;
}
int MotrBucket::rebuild_index(const DoutPrefixProvider *dpp)
{
/* there is no index table in dbstore. Not applicable */
return 0;
}
int MotrBucket::set_tag_timeout(const DoutPrefixProvider *dpp, uint64_t timeout)
{
/* XXX: CHECK: set tag timeout for all the bucket objects? */
return 0;
}
int MotrBucket::purge_instance(const DoutPrefixProvider *dpp)
{
/* XXX: CHECK: for dbstore only single instance supported.
* Remove all the objects for that instance? Anything extra needed?
*/
return 0;
}
int MotrBucket::set_acl(const DoutPrefixProvider *dpp, RGWAccessControlPolicy &acl, optional_yield y)
{
int ret = 0;
bufferlist aclbl;
acls = acl;
acl.encode(aclbl);
Attrs attrs = get_attrs();
attrs[RGW_ATTR_ACL] = aclbl;
// TODO: update bucket entry with the new attrs
return ret;
}
std::unique_ptr<Object> MotrBucket::get_object(const rgw_obj_key& k)
{
return std::make_unique<MotrObject>(this->store, k, this);
}
int MotrBucket::list(const DoutPrefixProvider *dpp, ListParams& params, int max, ListResults& results, optional_yield y)
{
int rc;
vector<string> keys(max);
vector<bufferlist> vals(max);
ldpp_dout(dpp, 20) << "bucket=" << info.bucket.name
<< " prefix=" << params.prefix
<< " marker=" << params.marker
<< " max=" << max << dendl;
// Retrieve all `max` number of pairs.
string bucket_index_iname = "motr.rgw.bucket.index." + info.bucket.name;
keys[0] = params.marker.empty() ? params.prefix :
params.marker.get_oid();
rc = store->next_query_by_name(bucket_index_iname, keys, vals, params.prefix,
params.delim);
if (rc < 0) {
ldpp_dout(dpp, 0) << "ERROR: NEXT query failed. " << rc << dendl;
return rc;
}
// Process the returned pairs to add into ListResults.
int i = 0;
for (; i < rc; ++i) {
if (vals[i].length() == 0) {
results.common_prefixes[keys[i]] = true;
} else {
rgw_bucket_dir_entry ent;
auto iter = vals[i].cbegin();
ent.decode(iter);
if (params.list_versions || ent.is_visible())
results.objs.emplace_back(std::move(ent));
}
}
if (i == max) {
results.is_truncated = true;
results.next_marker = keys[max - 1] + " ";
} else {
results.is_truncated = false;
}
return 0;
}
int MotrBucket::list_multiparts(const DoutPrefixProvider *dpp,
const string& prefix,
string& marker,
const string& delim,
const int& max_uploads,
vector<std::unique_ptr<MultipartUpload>>& uploads,
map<string, bool> *common_prefixes,
bool *is_truncated)
{
int rc;
vector<string> key_vec(max_uploads);
vector<bufferlist> val_vec(max_uploads);
string bucket_multipart_iname =
"motr.rgw.bucket." + this->get_name() + ".multiparts";
key_vec[0].clear();
key_vec[0].assign(marker.begin(), marker.end());
rc = store->next_query_by_name(bucket_multipart_iname, key_vec, val_vec);
if (rc < 0) {
ldpp_dout(dpp, 0) << "ERROR: NEXT query failed. " << rc << dendl;
return rc;
}
// Process the returned pairs to add into ListResults.
// The POC can only support listing all objects or selecting
// with prefix.
int ocount = 0;
rgw_obj_key last_obj_key;
*is_truncated = false;
for (const auto& bl: val_vec) {
if (bl.length() == 0)
break;
rgw_bucket_dir_entry ent;
auto iter = bl.cbegin();
ent.decode(iter);
if (prefix.size() &&
(0 != ent.key.name.compare(0, prefix.size(), prefix))) {
ldpp_dout(dpp, 20) << __PRETTY_FUNCTION__ <<
": skippping \"" << ent.key <<
"\" because doesn't match prefix" << dendl;
continue;
}
rgw_obj_key key(ent.key);
uploads.push_back(this->get_multipart_upload(key.name));
last_obj_key = key;
ocount++;
if (ocount == max_uploads) {
*is_truncated = true;
break;
}
}
marker = last_obj_key.name;
// What is common prefix? We don't handle it for now.
return 0;
}
int MotrBucket::abort_multiparts(const DoutPrefixProvider *dpp, CephContext *cct)
{
return 0;
}
void MotrStore::finalize(void)
{
// close connection with motr
m0_client_fini(this->instance, true);
}
const std::string& MotrZoneGroup::get_endpoint() const
{
if (!group.endpoints.empty()) {
return group.endpoints.front();
} else {
// use zonegroup's master zone endpoints
auto z = group.zones.find(group.master_zone);
if (z != group.zones.end() && !z->second.endpoints.empty()) {
return z->second.endpoints.front();
}
}
return empty;
}
bool MotrZoneGroup::placement_target_exists(std::string& target) const
{
return !!group.placement_targets.count(target);
}
int MotrZoneGroup::get_placement_target_names(std::set<std::string>& names) const
{
for (const auto& target : group.placement_targets) {
names.emplace(target.second.name);
}
return 0;
}
int MotrZoneGroup::get_placement_tier(const rgw_placement_rule& rule,
std::unique_ptr<PlacementTier>* tier)
{
std::map<std::string, RGWZoneGroupPlacementTarget>::const_iterator titer;
titer = group.placement_targets.find(rule.name);
if (titer == group.placement_targets.end()) {
return -ENOENT;
}
const auto& target_rule = titer->second;
std::map<std::string, RGWZoneGroupPlacementTier>::const_iterator ttier;
ttier = target_rule.tier_targets.find(rule.storage_class);
if (ttier == target_rule.tier_targets.end()) {
// not found
return -ENOENT;
}
PlacementTier* t;
t = new MotrPlacementTier(store, ttier->second);
if (!t)
return -ENOMEM;
tier->reset(t);
return 0;
}
ZoneGroup& MotrZone::get_zonegroup()
{
return zonegroup;
}
const std::string& MotrZone::get_id()
{
return zone_params->get_id();
}
const std::string& MotrZone::get_name() const
{
return zone_params->get_name();
}
bool MotrZone::is_writeable()
{
return true;
}
bool MotrZone::get_redirect_endpoint(std::string* endpoint)
{
return false;
}
bool MotrZone::has_zonegroup_api(const std::string& api) const
{
return (zonegroup->api_name == api);
}
const std::string& MotrZone::get_current_period_id()
{
return current_period->get_id();
}
std::unique_ptr<LuaManager> MotrStore::get_lua_manager()
{
return std::make_unique<MotrLuaManager>(this);
}
int MotrObject::get_obj_state(const DoutPrefixProvider* dpp, RGWObjState **_state, optional_yield y, bool follow_olh)
{
// Get object's metadata (those stored in rgw_bucket_dir_entry).
bufferlist bl;
if (this->store->get_obj_meta_cache()->get(dpp, this->get_key().get_oid(), bl)) {
// Cache misses.
string bucket_index_iname = "motr.rgw.bucket.index." + this->get_bucket()->get_name();
int rc = this->store->do_idx_op_by_name(bucket_index_iname,
M0_IC_GET, this->get_key().get_oid(), bl);
if (rc < 0) {
ldpp_dout(dpp, 0) << "Failed to get object's entry from bucket index. " << dendl;
return rc;
}
// Put into cache.
this->store->get_obj_meta_cache()->put(dpp, this->get_key().get_oid(), bl);
}
rgw_bucket_dir_entry ent;
bufferlist& blr = bl;
auto iter = blr.cbegin();
ent.decode(iter);
// Set object's type.
this->category = ent.meta.category;
// Set object state.
state.exists = true;
state.size = ent.meta.size;
state.accounted_size = ent.meta.size;
state.mtime = ent.meta.mtime;
state.has_attrs = true;
bufferlist etag_bl;
string& etag = ent.meta.etag;
ldpp_dout(dpp, 20) <<__func__<< ": object's etag: " << ent.meta.etag << dendl;
etag_bl.append(etag);
state.attrset[RGW_ATTR_ETAG] = etag_bl;
return 0;
}
MotrObject::~MotrObject() {
this->close_mobj();
}
// int MotrObject::read_attrs(const DoutPrefixProvider* dpp, Motr::Object::Read &read_op, optional_yield y, rgw_obj* target_obj)
// {
// read_op.params.attrs = &attrs;
// read_op.params.target_obj = target_obj;
// read_op.params.obj_size = &obj_size;
// read_op.params.lastmod = &mtime;
//
// return read_op.prepare(dpp);
// }
int MotrObject::set_obj_attrs(const DoutPrefixProvider* dpp, Attrs* setattrs, Attrs* delattrs, optional_yield y)
{
// TODO: implement
ldpp_dout(dpp, 20) <<__func__<< ": MotrObject::set_obj_attrs()" << dendl;
return 0;
}
int MotrObject::get_obj_attrs(optional_yield y, const DoutPrefixProvider* dpp, rgw_obj* target_obj)
{
if (this->category == RGWObjCategory::MultiMeta)
return 0;
string bname, key;
if (target_obj) {
bname = target_obj->bucket.name;
key = target_obj->key.get_oid();
} else {
bname = this->get_bucket()->get_name();
key = this->get_key().get_oid();
}
ldpp_dout(dpp, 20) << "MotrObject::get_obj_attrs(): "
<< bname << "/" << key << dendl;
// Get object's metadata (those stored in rgw_bucket_dir_entry).
bufferlist bl;
if (this->store->get_obj_meta_cache()->get(dpp, key, bl)) {
// Cache misses.
string bucket_index_iname = "motr.rgw.bucket.index." + bname;
int rc = this->store->do_idx_op_by_name(bucket_index_iname, M0_IC_GET, key, bl);
if (rc < 0) {
ldpp_dout(dpp, 0) << "Failed to get object's entry from bucket index. " << dendl;
return rc;
}
// Put into cache.
this->store->get_obj_meta_cache()->put(dpp, key, bl);
}
rgw_bucket_dir_entry ent;
bufferlist& blr = bl;
auto iter = blr.cbegin();
ent.decode(iter);
decode(attrs, iter);
return 0;
}
int MotrObject::modify_obj_attrs(const char* attr_name, bufferlist& attr_val, optional_yield y, const DoutPrefixProvider* dpp)
{
rgw_obj target = get_obj();
int r = get_obj_attrs(y, dpp, &target);
if (r < 0) {
return r;
}
set_atomic();
attrs[attr_name] = attr_val;
return set_obj_attrs(dpp, &attrs, nullptr, y);
}
int MotrObject::delete_obj_attrs(const DoutPrefixProvider* dpp, const char* attr_name, optional_yield y)
{
rgw_obj target = get_obj();
Attrs rmattr;
bufferlist bl;
set_atomic();
rmattr[attr_name] = bl;
return set_obj_attrs(dpp, nullptr, &rmattr, y);
}
bool MotrObject::is_expired() {
return false;
}
// Taken from rgw_rados.cc
void MotrObject::gen_rand_obj_instance_name()
{
enum {OBJ_INSTANCE_LEN = 32};
char buf[OBJ_INSTANCE_LEN + 1];
gen_rand_alphanumeric_no_underscore(store->ctx(), buf, OBJ_INSTANCE_LEN);
state.obj.key.set_instance(buf);
}
int MotrObject::omap_get_vals_by_keys(const DoutPrefixProvider *dpp, const std::string& oid,
const std::set<std::string>& keys,
Attrs* vals)
{
return 0;
}
int MotrObject::omap_set_val_by_key(const DoutPrefixProvider *dpp, const std::string& key, bufferlist& val,
bool must_exist, optional_yield y)
{
return 0;
}
int MotrObject::chown(User& new_user, const DoutPrefixProvider* dpp, optional_yield y)
{
return 0;
}
std::unique_ptr<MPSerializer> MotrObject::get_serializer(const DoutPrefixProvider *dpp,
const std::string& lock_name)
{
return std::make_unique<MPMotrSerializer>(dpp, store, this, lock_name);
}
int MotrObject::transition(Bucket* bucket,
const rgw_placement_rule& placement_rule,
const real_time& mtime,
uint64_t olh_epoch,
const DoutPrefixProvider* dpp,
optional_yield y)
{
return 0;
}
bool MotrObject::placement_rules_match(rgw_placement_rule& r1, rgw_placement_rule& r2)
{
/* XXX: support single default zone and zonegroup for now */
return true;
}
int MotrObject::dump_obj_layout(const DoutPrefixProvider *dpp, optional_yield y, Formatter* f)
{
return 0;
}
std::unique_ptr<Object::ReadOp> MotrObject::get_read_op()
{
return std::make_unique<MotrObject::MotrReadOp>(this);
}
MotrObject::MotrReadOp::MotrReadOp(MotrObject *_source) :
source(_source)
{ }
int MotrObject::MotrReadOp::prepare(optional_yield y, const DoutPrefixProvider* dpp)
{
int rc;
ldpp_dout(dpp, 20) <<__func__<< ": bucket=" << source->get_bucket()->get_name() << dendl;
rgw_bucket_dir_entry ent;
rc = source->get_bucket_dir_ent(dpp, ent);
if (rc < 0)
return rc;
// Set source object's attrs. The attrs is key/value map and is used
// in send_response_data() to set attributes, including etag.
bufferlist etag_bl;
string& etag = ent.meta.etag;
ldpp_dout(dpp, 20) <<__func__<< ": object's etag: " << ent.meta.etag << dendl;
etag_bl.append(etag.c_str(), etag.size());
source->get_attrs().emplace(std::move(RGW_ATTR_ETAG), std::move(etag_bl));
source->set_key(ent.key);
source->set_obj_size(ent.meta.size);
source->category = ent.meta.category;
*params.lastmod = ent.meta.mtime;
if (params.mod_ptr || params.unmod_ptr) {
// Convert all times go GMT to make them compatible
obj_time_weight src_weight;
src_weight.init(*params.lastmod, params.mod_zone_id, params.mod_pg_ver);
src_weight.high_precision = params.high_precision_time;
obj_time_weight dest_weight;
dest_weight.high_precision = params.high_precision_time;
// Check if-modified-since condition
if (params.mod_ptr && !params.if_nomatch) {
dest_weight.init(*params.mod_ptr, params.mod_zone_id, params.mod_pg_ver);
ldpp_dout(dpp, 10) << "If-Modified-Since: " << dest_weight << " & "
<< "Last-Modified: " << src_weight << dendl;
if (!(dest_weight < src_weight)) {
return -ERR_NOT_MODIFIED;
}
}
// Check if-unmodified-since condition
if (params.unmod_ptr && !params.if_match) {
dest_weight.init(*params.unmod_ptr, params.mod_zone_id, params.mod_pg_ver);
ldpp_dout(dpp, 10) << "If-UnModified-Since: " << dest_weight << " & "
<< "Last-Modified: " << src_weight << dendl;
if (dest_weight < src_weight) {
return -ERR_PRECONDITION_FAILED;
}
}
}
// Check if-match condition
if (params.if_match) {
string if_match_str = rgw_string_unquote(params.if_match);
ldpp_dout(dpp, 10) << "ETag: " << etag << " & "
<< "If-Match: " << if_match_str << dendl;
if (if_match_str.compare(etag) != 0) {
return -ERR_PRECONDITION_FAILED;
}
}
// Check if-none-match condition
if (params.if_nomatch) {
string if_nomatch_str = rgw_string_unquote(params.if_nomatch);
ldpp_dout(dpp, 10) << "ETag: " << etag << " & "
<< "If-NoMatch: " << if_nomatch_str << dendl;
if (if_nomatch_str.compare(etag) == 0) {
return -ERR_NOT_MODIFIED;
}
}
// Skip opening an empty object.
if(source->get_obj_size() == 0)
return 0;
// Open the object here.
if (source->category == RGWObjCategory::MultiMeta) {
ldpp_dout(dpp, 20) <<__func__<< ": open obj parts..." << dendl;
rc = source->get_part_objs(dpp, this->part_objs)? :
source->open_part_objs(dpp, this->part_objs);
return rc;
} else {
ldpp_dout(dpp, 20) <<__func__<< ": open object..." << dendl;
return source->open_mobj(dpp);
}
}
int MotrObject::MotrReadOp::read(int64_t off, int64_t end, bufferlist& bl, optional_yield y, const DoutPrefixProvider* dpp)
{
ldpp_dout(dpp, 20) << "MotrReadOp::read(): sync read." << dendl;
return 0;
}
// RGWGetObj::execute() calls ReadOp::iterate() to read object from 'off' to 'end'.
// The returned data is processed in 'cb' which is a chain of post-processing
// filters such as decompression, de-encryption and sending back data to client
// (RGWGetObj_CB::handle_dta which in turn calls RGWGetObj::get_data_cb() to
// send data back.).
//
// POC implements a simple sync version of iterate() function in which it reads
// a block of data each time and call 'cb' for post-processing.
int MotrObject::MotrReadOp::iterate(const DoutPrefixProvider* dpp, int64_t off, int64_t end, RGWGetDataCB* cb, optional_yield y)
{
int rc;
if (source->category == RGWObjCategory::MultiMeta)
rc = source->read_multipart_obj(dpp, off, end, cb, part_objs);
else
rc = source->read_mobj(dpp, off, end, cb);
return rc;
}
int MotrObject::MotrReadOp::get_attr(const DoutPrefixProvider* dpp, const char* name, bufferlist& dest, optional_yield y)
{
//return 0;
return -ENODATA;
}
std::unique_ptr<Object::DeleteOp> MotrObject::get_delete_op()
{
return std::make_unique<MotrObject::MotrDeleteOp>(this);
}
MotrObject::MotrDeleteOp::MotrDeleteOp(MotrObject *_source) :
source(_source)
{ }
// Implementation of DELETE OBJ also requires MotrObject::get_obj_state()
// to retrieve and set object's state from object's metadata.
//
// TODO:
// 1. The POC only remove the object's entry from bucket index and delete
// corresponding Motr objects. It doesn't handle the DeleteOp::params.
// Delete::delete_obj() in rgw_rados.cc shows how rados backend process the
// params.
// 2. Delete an object when its versioning is turned on.
int MotrObject::MotrDeleteOp::delete_obj(const DoutPrefixProvider* dpp, optional_yield y)
{
ldpp_dout(dpp, 20) << "delete " << source->get_key().get_oid() << " from " << source->get_bucket()->get_name() << dendl;
rgw_bucket_dir_entry ent;
int rc = source->get_bucket_dir_ent(dpp, ent);
if (rc < 0) {
return rc;
}
//TODO: When integrating with background GC for object deletion,
// we should consider adding object entry to GC before deleting the metadata.
// Delete from the cache first.
source->store->get_obj_meta_cache()->remove(dpp, source->get_key().get_oid());
// Delete the object's entry from the bucket index.
bufferlist bl;
string bucket_index_iname = "motr.rgw.bucket.index." + source->get_bucket()->get_name();
rc = source->store->do_idx_op_by_name(bucket_index_iname,
M0_IC_DEL, source->get_key().get_oid(), bl);
if (rc < 0) {
ldpp_dout(dpp, 0) << "Failed to del object's entry from bucket index. " << dendl;
return rc;
}
if (ent.meta.size == 0) {
ldpp_dout(dpp, 0) << __func__ << ": Object size is 0, not deleting motr object." << dendl;
return 0;
}
// Remove the motr objects.
if (source->category == RGWObjCategory::MultiMeta)
rc = source->delete_part_objs(dpp);
else
rc = source->delete_mobj(dpp);
if (rc < 0) {
ldpp_dout(dpp, 0) << "Failed to delete the object from Motr. " << dendl;
return rc;
}
//result.delete_marker = parent_op.result.delete_marker;
//result.version_id = parent_op.result.version_id;
return 0;
}
int MotrObject::delete_object(const DoutPrefixProvider* dpp, optional_yield y, bool prevent_versioning)
{
MotrObject::MotrDeleteOp del_op(this);
del_op.params.bucket_owner = bucket->get_info().owner;
del_op.params.versioning_status = bucket->get_info().versioning_status();
return del_op.delete_obj(dpp, y);
}
int MotrObject::copy_object(User* user,
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,
const ceph::real_time* mod_ptr,
const ceph::real_time* unmod_ptr,
bool high_precision_time,
const char* if_match,
const char* if_nomatch,
AttrsMod attrs_mod,
bool copy_if_newer,
Attrs& attrs,
RGWObjCategory category,
uint64_t olh_epoch,
boost::optional<ceph::real_time> delete_at,
std::string* version_id,
std::string* tag,
std::string* etag,
void (*progress_cb)(off_t, void *),
void* progress_data,
const DoutPrefixProvider* dpp,
optional_yield y)
{
return 0;
}
int MotrObject::swift_versioning_restore(bool& restored,
const DoutPrefixProvider* dpp)
{
return 0;
}
int MotrObject::swift_versioning_copy(const DoutPrefixProvider* dpp,
optional_yield y)
{
return 0;
}
MotrAtomicWriter::MotrAtomicWriter(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
MotrStore* _store,
const rgw_user& _owner,
const rgw_placement_rule *_ptail_placement_rule,
uint64_t _olh_epoch,
const std::string& _unique_tag) :
StoreWriter(dpp, y),
store(_store),
owner(_owner),
ptail_placement_rule(_ptail_placement_rule),
olh_epoch(_olh_epoch),
unique_tag(_unique_tag),
obj(_store, obj->get_key(), obj->get_bucket()),
old_obj(_store, obj->get_key(), obj->get_bucket()) {}
static const unsigned MAX_BUFVEC_NR = 256;
int MotrAtomicWriter::prepare(optional_yield y)
{
total_data_size = 0;
if (obj.is_opened())
return 0;
rgw_bucket_dir_entry ent;
int rc = old_obj.get_bucket_dir_ent(dpp, ent);
if (rc == 0) {
ldpp_dout(dpp, 20) << __func__ << ": object exists." << dendl;
}
rc = m0_bufvec_empty_alloc(&buf, MAX_BUFVEC_NR) ?:
m0_bufvec_alloc(&attr, MAX_BUFVEC_NR, 1) ?:
m0_indexvec_alloc(&ext, MAX_BUFVEC_NR);
if (rc != 0)
this->cleanup();
return rc;
}
int MotrObject::create_mobj(const DoutPrefixProvider *dpp, uint64_t sz)
{
if (mobj != nullptr) {
ldpp_dout(dpp, 0) <<__func__<< "ERROR: object is already opened" << dendl;
return -EINVAL;
}
int rc = m0_ufid_next(&ufid_gr, 1, &meta.oid);
if (rc != 0) {
ldpp_dout(dpp, 0) <<__func__<< "ERROR: m0_ufid_next() failed: " << rc << dendl;
return rc;
}
char fid_str[M0_FID_STR_LEN];
snprintf(fid_str, ARRAY_SIZE(fid_str), U128X_F, U128_P(&meta.oid));
ldpp_dout(dpp, 20) <<__func__<< ": sz=" << sz << " oid=" << fid_str << dendl;
int64_t lid = m0_layout_find_by_objsz(store->instance, nullptr, sz);
M0_ASSERT(lid > 0);
M0_ASSERT(mobj == nullptr);
mobj = new m0_obj();
m0_obj_init(mobj, &store->container.co_realm, &meta.oid, lid);
struct m0_op *op = nullptr;
mobj->ob_entity.en_flags |= M0_ENF_META;
rc = m0_entity_create(nullptr, &mobj->ob_entity, &op);
if (rc != 0) {
this->close_mobj();
ldpp_dout(dpp, 0) << "ERROR: m0_entity_create() failed: " << rc << dendl;
return rc;
}
ldpp_dout(dpp, 20) <<__func__<< ": call m0_op_launch()..." << dendl;
m0_op_launch(&op, 1);
rc = m0_op_wait(op, M0_BITS(M0_OS_FAILED, M0_OS_STABLE), M0_TIME_NEVER) ?:
m0_rc(op);
m0_op_fini(op);
m0_op_free(op);
if (rc != 0) {
this->close_mobj();
ldpp_dout(dpp, 0) << "ERROR: failed to create motr object: " << rc << dendl;
return rc;
}
meta.layout_id = mobj->ob_attr.oa_layout_id;
meta.pver = mobj->ob_attr.oa_pver;
ldpp_dout(dpp, 20) <<__func__<< ": lid=0x" << std::hex << meta.layout_id
<< std::dec << " rc=" << rc << dendl;
// TODO: add key:user+bucket+key+obj.meta.oid value:timestamp to
// gc.queue.index. See more at github.com/Seagate/cortx-rgw/issues/7.
return rc;
}
int MotrObject::open_mobj(const DoutPrefixProvider *dpp)
{
char fid_str[M0_FID_STR_LEN];
snprintf(fid_str, ARRAY_SIZE(fid_str), U128X_F, U128_P(&meta.oid));
ldpp_dout(dpp, 20) <<__func__<< ": oid=" << fid_str << dendl;
int rc;
if (meta.layout_id == 0) {
rgw_bucket_dir_entry ent;
rc = this->get_bucket_dir_ent(dpp, ent);
if (rc < 0) {
ldpp_dout(dpp, 0) << "ERROR: open_mobj() failed: rc=" << rc << dendl;
return rc;
}
}
if (meta.layout_id == 0)
return -ENOENT;
M0_ASSERT(mobj == nullptr);
mobj = new m0_obj();
memset(mobj, 0, sizeof *mobj);
m0_obj_init(mobj, &store->container.co_realm, &meta.oid, store->conf.mc_layout_id);
struct m0_op *op = nullptr;
mobj->ob_attr.oa_layout_id = meta.layout_id;
mobj->ob_attr.oa_pver = meta.pver;
mobj->ob_entity.en_flags |= M0_ENF_META;
rc = m0_entity_open(&mobj->ob_entity, &op);
if (rc != 0) {
ldpp_dout(dpp, 0) << "ERROR: m0_entity_open() failed: rc=" << rc << dendl;
this->close_mobj();
return rc;
}
m0_op_launch(&op, 1);
rc = m0_op_wait(op, M0_BITS(M0_OS_FAILED, M0_OS_STABLE), M0_TIME_NEVER) ?:
m0_rc(op);
m0_op_fini(op);
m0_op_free(op);
if (rc < 0) {
ldpp_dout(dpp, 10) << "ERROR: failed to open motr object: rc=" << rc << dendl;
this->close_mobj();
return rc;
}
ldpp_dout(dpp, 20) <<__func__<< ": rc=" << rc << dendl;
return 0;
}
int MotrObject::delete_mobj(const DoutPrefixProvider *dpp)
{
int rc;
char fid_str[M0_FID_STR_LEN];
snprintf(fid_str, ARRAY_SIZE(fid_str), U128X_F, U128_P(&meta.oid));
if (!meta.oid.u_hi || !meta.oid.u_lo) {
ldpp_dout(dpp, 20) << __func__ << ": invalid motr object oid=" << fid_str << dendl;
return -EINVAL;
}
ldpp_dout(dpp, 20) << __func__ << ": deleting motr object oid=" << fid_str << dendl;
// Open the object.
if (mobj == nullptr) {
rc = this->open_mobj(dpp);
if (rc < 0)
return rc;
}
// Create an DELETE op and execute it (sync version).
struct m0_op *op = nullptr;
mobj->ob_entity.en_flags |= M0_ENF_META;
rc = m0_entity_delete(&mobj->ob_entity, &op);
if (rc != 0) {
ldpp_dout(dpp, 0) << "ERROR: m0_entity_delete() failed: " << rc << dendl;
return rc;
}
m0_op_launch(&op, 1);
rc = m0_op_wait(op, M0_BITS(M0_OS_FAILED, M0_OS_STABLE), M0_TIME_NEVER) ?:
m0_rc(op);
m0_op_fini(op);
m0_op_free(op);
if (rc < 0) {
ldpp_dout(dpp, 0) << "ERROR: failed to open motr object: " << rc << dendl;
return rc;
}
this->close_mobj();
return 0;
}
void MotrObject::close_mobj()
{
if (mobj == nullptr)
return;
m0_obj_fini(mobj);
delete mobj; mobj = nullptr;
}
int MotrObject::write_mobj(const DoutPrefixProvider *dpp, bufferlist&& data, uint64_t offset)
{
int rc;
unsigned bs, left;
struct m0_op *op;
char *start, *p;
struct m0_bufvec buf;
struct m0_bufvec attr;
struct m0_indexvec ext;
left = data.length();
if (left == 0)
return 0;
rc = m0_bufvec_empty_alloc(&buf, 1) ?:
m0_bufvec_alloc(&attr, 1, 1) ?:
m0_indexvec_alloc(&ext, 1);
if (rc != 0)
goto out;
bs = this->get_optimal_bs(left);
ldpp_dout(dpp, 20) <<__func__<< ": left=" << left << " bs=" << bs << dendl;
start = data.c_str();
for (p = start; left > 0; left -= bs, p += bs, offset += bs) {
if (left < bs)
bs = this->get_optimal_bs(left);
if (left < bs) {
data.append_zero(bs - left);
left = bs;
p = data.c_str();
}
buf.ov_buf[0] = p;
buf.ov_vec.v_count[0] = bs;
ext.iv_index[0] = offset;
ext.iv_vec.v_count[0] = bs;
attr.ov_vec.v_count[0] = 0;
op = nullptr;
rc = m0_obj_op(this->mobj, M0_OC_WRITE, &ext, &buf, &attr, 0, 0, &op);
if (rc != 0)
goto out;
m0_op_launch(&op, 1);
rc = m0_op_wait(op, M0_BITS(M0_OS_FAILED, M0_OS_STABLE), M0_TIME_NEVER) ?:
m0_rc(op);
m0_op_fini(op);
m0_op_free(op);
if (rc != 0)
goto out;
}
out:
m0_indexvec_free(&ext);
m0_bufvec_free(&attr);
m0_bufvec_free2(&buf);
return rc;
}
int MotrObject::read_mobj(const DoutPrefixProvider* dpp, int64_t off, int64_t end, RGWGetDataCB* cb)
{
int rc;
unsigned bs, actual, left;
struct m0_op *op;
struct m0_bufvec buf;
struct m0_bufvec attr;
struct m0_indexvec ext;
// make end pointer exclusive:
// it's easier to work with it this way
end++;
ldpp_dout(dpp, 20) << "MotrObject::read_mobj(): off=" << off <<
" end=" << end << dendl;
// As `off` may not be parity group size aligned, even using optimal
// buffer block size, simply reading data from offset `off` could come
// across parity group boundary. And Motr only allows page-size aligned
// offset.
//
// The optimal size of each IO should also take into account the data
// transfer size to s3 client. For example, 16MB may be nice to read
// data from motr, but it could be too big for network transfer.
//
// TODO: We leave proper handling of offset in the future.
bs = this->get_optimal_bs(end - off);
ldpp_dout(dpp, 20) << "MotrObject::read_mobj(): bs=" << bs << dendl;
rc = m0_bufvec_empty_alloc(&buf, 1) ? :
m0_bufvec_alloc(&attr, 1, 1) ? :
m0_indexvec_alloc(&ext, 1);
if (rc < 0)
goto out;
left = end - off;
for (; left > 0; off += actual) {
if (left < bs)
bs = this->get_optimal_bs(left);
actual = bs;
if (left < bs)
actual = left;
ldpp_dout(dpp, 20) << "MotrObject::read_mobj(): off=" << off <<
" actual=" << actual << dendl;
bufferlist bl;
buf.ov_buf[0] = bl.append_hole(bs).c_str();
buf.ov_vec.v_count[0] = bs;
ext.iv_index[0] = off;
ext.iv_vec.v_count[0] = bs;
attr.ov_vec.v_count[0] = 0;
left -= actual;
// Read from Motr.
op = nullptr;
rc = m0_obj_op(this->mobj, M0_OC_READ, &ext, &buf, &attr, 0, 0, &op);
ldpp_dout(dpp, 20) << "MotrObject::read_mobj(): init read op rc=" << rc << dendl;
if (rc != 0) {
ldpp_dout(dpp, 0) << __func__ << ": read failed during m0_obj_op, rc=" << rc << dendl;
goto out;
}
m0_op_launch(&op, 1);
rc = m0_op_wait(op, M0_BITS(M0_OS_FAILED, M0_OS_STABLE), M0_TIME_NEVER) ?:
m0_rc(op);
m0_op_fini(op);
m0_op_free(op);
if (rc != 0) {
ldpp_dout(dpp, 0) << __func__ << ": read failed, m0_op_wait rc=" << rc << dendl;
goto out;
}
// Call `cb` to process returned data.
ldpp_dout(dpp, 20) << "MotrObject::read_mobj(): call cb to process data" << dendl;
cb->handle_data(bl, 0, actual);
}
out:
m0_indexvec_free(&ext);
m0_bufvec_free(&attr);
m0_bufvec_free2(&buf);
this->close_mobj();
return rc;
}
int MotrObject::get_bucket_dir_ent(const DoutPrefixProvider *dpp, rgw_bucket_dir_entry& ent)
{
int rc = 0;
string bucket_index_iname = "motr.rgw.bucket.index." + this->get_bucket()->get_name();
int max = 1000;
vector<string> keys(max);
vector<bufferlist> vals(max);
bufferlist bl;
bufferlist::const_iterator iter;
if (this->get_bucket()->get_info().versioning_status() == BUCKET_VERSIONED ||
this->get_bucket()->get_info().versioning_status() == BUCKET_SUSPENDED) {
rgw_bucket_dir_entry ent_to_check;
if (this->store->get_obj_meta_cache()->get(dpp, this->get_name(), bl) == 0) {
iter = bl.cbegin();
ent_to_check.decode(iter);
if (ent_to_check.is_current()) {
ent = ent_to_check;
rc = 0;
goto out;
}
}
ldpp_dout(dpp, 20) <<__func__<< ": versioned bucket!" << dendl;
keys[0] = this->get_name();
rc = store->next_query_by_name(bucket_index_iname, keys, vals);
if (rc < 0) {
ldpp_dout(dpp, 0) << __func__ << "ERROR: NEXT query failed. " << rc << dendl;
return rc;
}
rc = -ENOENT;
for (const auto& bl: vals) {
if (bl.length() == 0)
break;
iter = bl.cbegin();
ent_to_check.decode(iter);
if (ent_to_check.is_current()) {
ldpp_dout(dpp, 20) <<__func__<< ": found current version!" << dendl;
ent = ent_to_check;
rc = 0;
this->store->get_obj_meta_cache()->put(dpp, this->get_name(), bl);
break;
}
}
} else {
if (this->store->get_obj_meta_cache()->get(dpp, this->get_key().get_oid(), bl)) {
ldpp_dout(dpp, 20) <<__func__<< ": non-versioned bucket!" << dendl;
rc = this->store->do_idx_op_by_name(bucket_index_iname,
M0_IC_GET, this->get_key().get_oid(), bl);
if (rc < 0) {
ldpp_dout(dpp, 0) << __func__ << "ERROR: failed to get object's entry from bucket index: rc="
<< rc << dendl;
return rc;
}
this->store->get_obj_meta_cache()->put(dpp, this->get_key().get_oid(), bl);
}
bufferlist& blr = bl;
iter = blr.cbegin();
ent.decode(iter);
}
out:
if (rc == 0) {
sal::Attrs dummy;
decode(dummy, iter);
meta.decode(iter);
ldpp_dout(dpp, 20) <<__func__<< ": lid=0x" << std::hex << meta.layout_id << dendl;
char fid_str[M0_FID_STR_LEN];
snprintf(fid_str, ARRAY_SIZE(fid_str), U128X_F, U128_P(&meta.oid));
ldpp_dout(dpp, 70) << __func__ << ": oid=" << fid_str << dendl;
} else
ldpp_dout(dpp, 0) <<__func__<< ": rc=" << rc << dendl;
return rc;
}
int MotrObject::update_version_entries(const DoutPrefixProvider *dpp)
{
int rc;
int max = 10;
vector<string> keys(max);
vector<bufferlist> vals(max);
string bucket_index_iname = "motr.rgw.bucket.index." + this->get_bucket()->get_name();
keys[0] = this->get_name();
rc = store->next_query_by_name(bucket_index_iname, keys, vals);
ldpp_dout(dpp, 20) << "get all versions, name = " << this->get_name() << "rc = " << rc << dendl;
if (rc < 0) {
ldpp_dout(dpp, 0) << "ERROR: NEXT query failed. " << rc << dendl;
return rc;
}
// no entries returned.
if (rc == 0)
return 0;
for (const auto& bl: vals) {
if (bl.length() == 0)
break;
rgw_bucket_dir_entry ent;
auto iter = bl.cbegin();
ent.decode(iter);
if (0 != ent.key.name.compare(0, this->get_name().size(), this->get_name()))
continue;
if (!ent.is_current())
continue;
// Remove from the cache.
store->get_obj_meta_cache()->remove(dpp, this->get_name());
rgw::sal::Attrs attrs;
decode(attrs, iter);
MotrObject::Meta meta;
meta.decode(iter);
ent.flags = rgw_bucket_dir_entry::FLAG_VER;
string key;
if (ent.key.instance.empty())
key = ent.key.name;
else {
char buf[ent.key.name.size() + ent.key.instance.size() + 16];
snprintf(buf, sizeof(buf), "%s[%s]", ent.key.name.c_str(), ent.key.instance.c_str());
key = buf;
}
ldpp_dout(dpp, 20) << "update one version, key = " << key << dendl;
bufferlist ent_bl;
ent.encode(ent_bl);
encode(attrs, ent_bl);
meta.encode(ent_bl);
rc = store->do_idx_op_by_name(bucket_index_iname,
M0_IC_PUT, key, ent_bl);
if (rc < 0)
break;
}
return rc;
}
// Scan object_nnn_part_index to get all parts then open their motr objects.
// TODO: all parts are opened in the POC. But for a large object, for example
// a 5GB object will have about 300 parts (for default 15MB part). A better
// way of managing opened object may be needed.
int MotrObject::get_part_objs(const DoutPrefixProvider* dpp,
std::map<int, std::unique_ptr<MotrObject>>& part_objs)
{
int rc;
int max_parts = 1000;
int marker = 0;
uint64_t off = 0;
bool truncated = false;
std::unique_ptr<rgw::sal::MultipartUpload> upload;
upload = this->get_bucket()->get_multipart_upload(this->get_name(), string());
do {
rc = upload->list_parts(dpp, store->ctx(), max_parts, marker, &marker, &truncated);
if (rc == -ENOENT) {
rc = -ERR_NO_SUCH_UPLOAD;
}
if (rc < 0)
return rc;
std::map<uint32_t, std::unique_ptr<MultipartPart>>& parts = upload->get_parts();
for (auto part_iter = parts.begin(); part_iter != parts.end(); ++part_iter) {
MultipartPart *mpart = part_iter->second.get();
MotrMultipartPart *mmpart = static_cast<MotrMultipartPart *>(mpart);
uint32_t part_num = mmpart->get_num();
uint64_t part_size = mmpart->get_size();
string part_obj_name = this->get_bucket()->get_name() + "." +
this->get_key().get_oid() +
".part." + std::to_string(part_num);
std::unique_ptr<rgw::sal::Object> obj;
obj = this->bucket->get_object(rgw_obj_key(part_obj_name));
std::unique_ptr<rgw::sal::MotrObject> mobj(static_cast<rgw::sal::MotrObject *>(obj.release()));
ldpp_dout(dpp, 20) << "get_part_objs: off = " << off << ", size = " << part_size << dendl;
mobj->part_off = off;
mobj->part_size = part_size;
mobj->part_num = part_num;
mobj->meta = mmpart->meta;
part_objs.emplace(part_num, std::move(mobj));
off += part_size;
}
} while (truncated);
return 0;
}
int MotrObject::open_part_objs(const DoutPrefixProvider* dpp,
std::map<int, std::unique_ptr<MotrObject>>& part_objs)
{
//for (auto& iter: part_objs) {
for (auto iter = part_objs.begin(); iter != part_objs.end(); ++iter) {
MotrObject* obj = static_cast<MotrObject *>(iter->second.get());
ldpp_dout(dpp, 20) << "open_part_objs: name = " << obj->get_name() << dendl;
int rc = obj->open_mobj(dpp);
if (rc < 0)
return rc;
}
return 0;
}
int MotrObject::delete_part_objs(const DoutPrefixProvider* dpp)
{
std::unique_ptr<rgw::sal::MultipartUpload> upload;
upload = this->get_bucket()->get_multipart_upload(this->get_name(), string());
std::unique_ptr<rgw::sal::MotrMultipartUpload> mupload(static_cast<rgw::sal::MotrMultipartUpload *>(upload.release()));
return mupload->delete_parts(dpp);
}
int MotrObject::read_multipart_obj(const DoutPrefixProvider* dpp,
int64_t off, int64_t end, RGWGetDataCB* cb,
std::map<int, std::unique_ptr<MotrObject>>& part_objs)
{
int64_t cursor = off;
ldpp_dout(dpp, 20) << "read_multipart_obj: off=" << off << " end=" << end << dendl;
// Find the parts which are in the (off, end) range and
// read data from it. Note: `end` argument is inclusive.
for (auto iter = part_objs.begin(); iter != part_objs.end(); ++iter) {
MotrObject* obj = static_cast<MotrObject *>(iter->second.get());
int64_t part_off = obj->part_off;
int64_t part_size = obj->part_size;
int64_t part_end = obj->part_off + obj->part_size - 1;
ldpp_dout(dpp, 20) << "read_multipart_obj: part_off=" << part_off
<< " part_end=" << part_end << dendl;
if (part_end < off)
continue;
int64_t local_off = cursor - obj->part_off;
int64_t local_end = part_end < end? part_size - 1 : end - part_off;
ldpp_dout(dpp, 20) << "real_multipart_obj: name=" << obj->get_name()
<< " local_off=" << local_off
<< " local_end=" << local_end << dendl;
int rc = obj->read_mobj(dpp, local_off, local_end, cb);
if (rc < 0)
return rc;
cursor = part_end + 1;
if (cursor > end)
break;
}
return 0;
}
static unsigned roundup(unsigned x, unsigned by)
{
return ((x - 1) / by + 1) * by;
}
unsigned MotrObject::get_optimal_bs(unsigned len)
{
struct m0_pool_version *pver;
pver = m0_pool_version_find(&store->instance->m0c_pools_common,
&mobj->ob_attr.oa_pver);
M0_ASSERT(pver != nullptr);
struct m0_pdclust_attr *pa = &pver->pv_attr;
uint64_t lid = M0_OBJ_LAYOUT_ID(meta.layout_id);
unsigned unit_sz = m0_obj_layout_id_to_unit_size(lid);
unsigned grp_sz = unit_sz * pa->pa_N;
// bs should be max 4-times pool-width deep counting by 1MB units, or
// 8-times deep counting by 512K units, 16-times deep by 256K units,
// and so on. Several units to one target will be aggregated to make
// fewer network RPCs, disk i/o operations and BE transactions.
// For unit sizes of 32K or less, the depth is 128, which
// makes it 32K * 128 == 4MB - the maximum amount per target when
// the performance is still good on LNet (which has max 1MB frames).
// TODO: it may be different on libfabric, should be re-measured.
unsigned depth = 128 / ((unit_sz + 0x7fff) / 0x8000);
if (depth == 0)
depth = 1;
// P * N / (N + K + S) - number of data units to span the pool-width
unsigned max_bs = depth * unit_sz * pa->pa_P * pa->pa_N /
(pa->pa_N + pa->pa_K + pa->pa_S);
max_bs = roundup(max_bs, grp_sz); // multiple of group size
if (len >= max_bs)
return max_bs;
else if (len <= grp_sz)
return grp_sz;
else
return roundup(len, grp_sz);
}
void MotrAtomicWriter::cleanup()
{
m0_indexvec_free(&ext);
m0_bufvec_free(&attr);
m0_bufvec_free2(&buf);
acc_data.clear();
obj.close_mobj();
old_obj.close_mobj();
}
unsigned MotrAtomicWriter::populate_bvec(unsigned len, bufferlist::iterator &bi)
{
unsigned i, l, done = 0;
const char *data;
for (i = 0; i < MAX_BUFVEC_NR && len > 0; ++i) {
l = bi.get_ptr_and_advance(len, &data);
buf.ov_buf[i] = (char*)data;
buf.ov_vec.v_count[i] = l;
ext.iv_index[i] = acc_off;
ext.iv_vec.v_count[i] = l;
attr.ov_vec.v_count[i] = 0;
acc_off += l;
len -= l;
done += l;
}
buf.ov_vec.v_nr = i;
ext.iv_vec.v_nr = i;
return done;
}
int MotrAtomicWriter::write()
{
int rc;
unsigned bs, left;
struct m0_op *op;
bufferlist::iterator bi;
left = acc_data.length();
if (!obj.is_opened()) {
rc = obj.create_mobj(dpp, left);
if (rc == -EEXIST)
rc = obj.open_mobj(dpp);
if (rc != 0) {
char fid_str[M0_FID_STR_LEN];
snprintf(fid_str, ARRAY_SIZE(fid_str), U128X_F, U128_P(&obj.meta.oid));
ldpp_dout(dpp, 0) << "ERROR: failed to create/open motr object "
<< fid_str << " (" << obj.get_bucket()->get_name()
<< "/" << obj.get_key().get_oid() << "): rc=" << rc
<< dendl;
goto err;
}
}
total_data_size += left;
bs = obj.get_optimal_bs(left);
ldpp_dout(dpp, 20) <<__func__<< ": left=" << left << " bs=" << bs << dendl;
bi = acc_data.begin();
while (left > 0) {
if (left < bs)
bs = obj.get_optimal_bs(left);
if (left < bs) {
acc_data.append_zero(bs - left);
auto off = bi.get_off();
bufferlist tmp;
acc_data.splice(off, bs, &tmp);
acc_data.clear();
acc_data.append(tmp.c_str(), bs); // make it a single buf
bi = acc_data.begin();
left = bs;
}
left -= this->populate_bvec(bs, bi);
op = nullptr;
rc = m0_obj_op(obj.mobj, M0_OC_WRITE, &ext, &buf, &attr, 0, 0, &op);
if (rc != 0)
goto err;
m0_op_launch(&op, 1);
rc = m0_op_wait(op, M0_BITS(M0_OS_FAILED, M0_OS_STABLE), M0_TIME_NEVER) ?:
m0_rc(op);
m0_op_fini(op);
m0_op_free(op);
if (rc != 0)
goto err;
}
acc_data.clear();
return 0;
err:
this->cleanup();
return rc;
}
static const unsigned MAX_ACC_SIZE = 32 * 1024 * 1024;
// Accumulate enough data first to make a reasonable decision about the
// optimal unit size for a new object, or bs for existing object (32M seems
// enough for 4M units in 8+2 parity groups, a common config on wide pools),
// and then launch the write operations.
int MotrAtomicWriter::process(bufferlist&& data, uint64_t offset)
{
if (data.length() == 0) { // last call, flush data
int rc = 0;
if (acc_data.length() != 0)
rc = this->write();
this->cleanup();
return rc;
}
if (acc_data.length() == 0)
acc_off = offset;
acc_data.append(std::move(data));
if (acc_data.length() < MAX_ACC_SIZE)
return 0;
return this->write();
}
int MotrAtomicWriter::complete(size_t accounted_size, const std::string& etag,
ceph::real_time *mtime, ceph::real_time set_mtime,
std::map<std::string, bufferlist>& attrs,
ceph::real_time delete_at,
const char *if_match, const char *if_nomatch,
const std::string *user_data,
rgw_zone_set *zones_trace, bool *canceled,
optional_yield y)
{
int rc = 0;
if (acc_data.length() != 0) { // check again, just in case
rc = this->write();
this->cleanup();
if (rc != 0)
return rc;
}
bufferlist bl;
rgw_bucket_dir_entry ent;
// Set rgw_bucet_dir_entry. Some of the member of this structure may not
// apply to motr. For example the storage_class.
//
// Checkout AtomicObjectProcessor::complete() in rgw_putobj_processor.cc
// and RGWRados::Object::Write::write_meta() in rgw_rados.cc for what and
// how to set the dir entry. Only set the basic ones for POC, no ACLs and
// other attrs.
obj.get_key().get_index_key(&ent.key);
ent.meta.size = total_data_size;
ent.meta.accounted_size = total_data_size;
ent.meta.mtime = real_clock::is_zero(set_mtime)? ceph::real_clock::now() : set_mtime;
ent.meta.etag = etag;
ent.meta.owner = owner.to_str();
ent.meta.owner_display_name = obj.get_bucket()->get_owner()->get_display_name();
bool is_versioned = obj.get_key().have_instance();
if (is_versioned)
ent.flags = rgw_bucket_dir_entry::FLAG_VER | rgw_bucket_dir_entry::FLAG_CURRENT;
ldpp_dout(dpp, 20) <<__func__<< ": key=" << obj.get_key().get_oid()
<< " etag: " << etag << " user_data=" << user_data << dendl;
if (user_data)
ent.meta.user_data = *user_data;
ent.encode(bl);
RGWBucketInfo &info = obj.get_bucket()->get_info();
if (info.obj_lock_enabled() && info.obj_lock.has_rule()) {
auto iter = attrs.find(RGW_ATTR_OBJECT_RETENTION);
if (iter == attrs.end()) {
real_time lock_until_date = info.obj_lock.get_lock_until_date(ent.meta.mtime);
string mode = info.obj_lock.get_mode();
RGWObjectRetention obj_retention(mode, lock_until_date);
bufferlist retention_bl;
obj_retention.encode(retention_bl);
attrs[RGW_ATTR_OBJECT_RETENTION] = retention_bl;
}
}
encode(attrs, bl);
obj.meta.encode(bl);
ldpp_dout(dpp, 20) <<__func__<< ": lid=0x" << std::hex << obj.meta.layout_id
<< dendl;
if (is_versioned) {
// get the list of all versioned objects with the same key and
// unset their FLAG_CURRENT later, if do_idx_op_by_name() is successful.
// Note: without distributed lock on the index - it is possible that 2
// CURRENT entries would appear in the bucket. For example, consider the
// following scenario when two clients are trying to add the new object
// version concurrently:
// client 1: reads all the CURRENT entries
// client 2: updates the index and sets the new CURRENT
// client 1: updates the index and sets the new CURRENT
// At the step (1) client 1 would not see the new current record from step (2),
// so it won't update it. As a result, two CURRENT version entries will appear
// in the bucket.
// TODO: update the current version (unset the flag) and insert the new current
// version can be launched in one motr op. This requires change at do_idx_op()
// and do_idx_op_by_name().
rc = obj.update_version_entries(dpp);
if (rc < 0)
return rc;
}
// Insert an entry into bucket index.
string bucket_index_iname = "motr.rgw.bucket.index." + obj.get_bucket()->get_name();
rc = store->do_idx_op_by_name(bucket_index_iname,
M0_IC_PUT, obj.get_key().get_oid(), bl);
if (rc == 0)
store->get_obj_meta_cache()->put(dpp, obj.get_key().get_oid(), bl);
if (old_obj.get_bucket()->get_info().versioning_status() != BUCKET_VERSIONED) {
// Delete old object data if exists.
old_obj.delete_mobj(dpp);
}
// TODO: We need to handle the object leak caused by parallel object upload by
// making use of background gc, which is currently not enabled for motr.
return rc;
}
int MotrMultipartUpload::delete_parts(const DoutPrefixProvider *dpp)
{
int rc;
int max_parts = 1000;
int marker = 0;
bool truncated = false;
// Scan all parts and delete the corresponding motr objects.
do {
rc = this->list_parts(dpp, store->ctx(), max_parts, marker, &marker, &truncated);
if (rc == -ENOENT) {
truncated = false;
rc = 0;
}
if (rc < 0)
return rc;
std::map<uint32_t, std::unique_ptr<MultipartPart>>& parts = this->get_parts();
for (auto part_iter = parts.begin(); part_iter != parts.end(); ++part_iter) {
MultipartPart *mpart = part_iter->second.get();
MotrMultipartPart *mmpart = static_cast<MotrMultipartPart *>(mpart);
uint32_t part_num = mmpart->get_num();
// Delete the part object. Note that the part object is not
// inserted into bucket index, only the corresponding motr object
// needs to be delete. That is why we don't call
// MotrObject::delete_object().
string part_obj_name = bucket->get_name() + "." +
mp_obj.get_key() +
".part." + std::to_string(part_num);
std::unique_ptr<rgw::sal::Object> obj;
obj = this->bucket->get_object(rgw_obj_key(part_obj_name));
std::unique_ptr<rgw::sal::MotrObject> mobj(static_cast<rgw::sal::MotrObject *>(obj.release()));
mobj->meta = mmpart->meta;
rc = mobj->delete_mobj(dpp);
if (rc < 0) {
ldpp_dout(dpp, 0) << __func__ << ": Failed to delete object from Motr. rc=" << rc << dendl;
return rc;
}
}
} while (truncated);
// Delete object part index.
std::string oid = mp_obj.get_key();
string obj_part_iname = "motr.rgw.object." + bucket->get_name() + "." + oid + ".parts";
return store->delete_motr_idx_by_name(obj_part_iname);
}
int MotrMultipartUpload::abort(const DoutPrefixProvider *dpp, CephContext *cct)
{
int rc;
// Check if multipart upload exists
bufferlist bl;
std::unique_ptr<rgw::sal::Object> meta_obj;
meta_obj = get_meta_obj();
string bucket_multipart_iname =
"motr.rgw.bucket." + meta_obj->get_bucket()->get_name() + ".multiparts";
rc = store->do_idx_op_by_name(bucket_multipart_iname,
M0_IC_GET, meta_obj->get_key().to_str(), bl);
if (rc < 0) {
ldpp_dout(dpp, 0) << __func__ << ": Failed to get multipart upload. rc=" << rc << dendl;
return rc == -ENOENT ? -ERR_NO_SUCH_UPLOAD : rc;
}
// Scan all parts and delete the corresponding motr objects.
rc = this->delete_parts(dpp);
if (rc < 0)
return rc;
bl.clear();
// Remove the upload from bucket multipart index.
rc = store->do_idx_op_by_name(bucket_multipart_iname,
M0_IC_DEL, meta_obj->get_key().get_oid(), bl);
return rc;
}
std::unique_ptr<rgw::sal::Object> MotrMultipartUpload::get_meta_obj()
{
std::unique_ptr<rgw::sal::Object> obj = bucket->get_object(rgw_obj_key(get_meta(), string(), mp_ns));
std::unique_ptr<rgw::sal::MotrObject> mobj(static_cast<rgw::sal::MotrObject *>(obj.release()));
mobj->set_category(RGWObjCategory::MultiMeta);
return mobj;
}
struct motr_multipart_upload_info
{
rgw_placement_rule dest_placement;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(dest_placement, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(dest_placement, bl);
DECODE_FINISH(bl);
}
};
WRITE_CLASS_ENCODER(motr_multipart_upload_info)
int MotrMultipartUpload::init(const DoutPrefixProvider *dpp, optional_yield y,
ACLOwner& _owner,
rgw_placement_rule& dest_placement, rgw::sal::Attrs& attrs)
{
int rc;
std::string oid = mp_obj.get_key();
owner = _owner;
do {
char buf[33];
string tmp_obj_name;
gen_rand_alphanumeric(store->ctx(), buf, sizeof(buf) - 1);
std::string upload_id = MULTIPART_UPLOAD_ID_PREFIX; /* v2 upload id */
upload_id.append(buf);
mp_obj.init(oid, upload_id);
tmp_obj_name = mp_obj.get_meta();
std::unique_ptr<rgw::sal::Object> obj;
obj = bucket->get_object(rgw_obj_key(tmp_obj_name, string(), mp_ns));
// the meta object will be indexed with 0 size, we c
obj->set_in_extra_data(true);
obj->set_hash_source(oid);
motr_multipart_upload_info upload_info;
upload_info.dest_placement = dest_placement;
bufferlist mpbl;
encode(upload_info, mpbl);
// Create an initial entry in the bucket. The entry will be
// updated when multipart upload is completed, for example,
// size, etag etc.
bufferlist bl;
rgw_bucket_dir_entry ent;
obj->get_key().get_index_key(&ent.key);
ent.meta.owner = owner.get_id().to_str();
ent.meta.category = RGWObjCategory::MultiMeta;
ent.meta.mtime = ceph::real_clock::now();
ent.meta.user_data.assign(mpbl.c_str(), mpbl.c_str() + mpbl.length());
ent.encode(bl);
// Insert an entry into bucket multipart index so it is not shown
// when listing a bucket.
string bucket_multipart_iname =
"motr.rgw.bucket." + obj->get_bucket()->get_name() + ".multiparts";
rc = store->do_idx_op_by_name(bucket_multipart_iname,
M0_IC_PUT, obj->get_key().get_oid(), bl);
} while (rc == -EEXIST);
if (rc < 0)
return rc;
// Create object part index.
// TODO: add bucket as part of the name.
string obj_part_iname = "motr.rgw.object." + bucket->get_name() + "." + oid + ".parts";
ldpp_dout(dpp, 20) << "MotrMultipartUpload::init(): object part index=" << obj_part_iname << dendl;
rc = store->create_motr_idx_by_name(obj_part_iname);
if (rc == -EEXIST)
rc = 0;
if (rc < 0)
// TODO: clean the bucket index entry
ldpp_dout(dpp, 0) << "Failed to create object multipart index " << obj_part_iname << dendl;
return rc;
}
int MotrMultipartUpload::list_parts(const DoutPrefixProvider *dpp, CephContext *cct,
int num_parts, int marker,
int *next_marker, bool *truncated,
bool assume_unsorted)
{
int rc;
vector<string> key_vec(num_parts);
vector<bufferlist> val_vec(num_parts);
std::string oid = mp_obj.get_key();
string obj_part_iname = "motr.rgw.object." + bucket->get_name() + "." + oid + ".parts";
ldpp_dout(dpp, 20) << __func__ << ": object part index = " << obj_part_iname << dendl;
key_vec[0].clear();
key_vec[0] = "part.";
char buf[32];
snprintf(buf, sizeof(buf), "%08d", marker + 1);
key_vec[0].append(buf);
rc = store->next_query_by_name(obj_part_iname, key_vec, val_vec);
if (rc < 0) {
ldpp_dout(dpp, 0) << "ERROR: NEXT query failed. " << rc << dendl;
return rc;
}
int last_num = 0;
int part_cnt = 0;
uint32_t expected_next = 0;
ldpp_dout(dpp, 20) << __func__ << ": marker = " << marker << dendl;
for (const auto& bl: val_vec) {
if (bl.length() == 0)
break;
RGWUploadPartInfo info;
auto iter = bl.cbegin();
info.decode(iter);
rgw::sal::Attrs attrs_dummy;
decode(attrs_dummy, iter);
MotrObject::Meta meta;
meta.decode(iter);
ldpp_dout(dpp, 20) << __func__ << ": part_num=" << info.num
<< " part_size=" << info.size << dendl;
ldpp_dout(dpp, 20) << __func__ << ": meta:oid=[" << meta.oid.u_hi << "," << meta.oid.u_lo
<< "], meta:pvid=[" << meta.pver.f_container << "," << meta.pver.f_key
<< "], meta:layout id=" << meta.layout_id << dendl;
if (!expected_next)
expected_next = info.num + 1;
else if (expected_next && info.num != expected_next)
return -EINVAL;
else expected_next = info.num + 1;
if ((int)info.num > marker) {
last_num = info.num;
parts.emplace(info.num, std::make_unique<MotrMultipartPart>(info, meta));
}
part_cnt++;
}
// Does it have more parts?
if (truncated)
*truncated = part_cnt < num_parts? false : true;
ldpp_dout(dpp, 20) << __func__ << ": truncated=" << *truncated << dendl;
if (next_marker)
*next_marker = last_num;
return 0;
}
// Heavily copy from rgw_sal_rados.cc
int MotrMultipartUpload::complete(const DoutPrefixProvider *dpp,
optional_yield y, CephContext* cct,
map<int, string>& part_etags,
list<rgw_obj_index_key>& remove_objs,
uint64_t& accounted_size, bool& compressed,
RGWCompressionInfo& cs_info, off_t& off,
std::string& tag, ACLOwner& owner,
uint64_t olh_epoch,
rgw::sal::Object* target_obj)
{
char final_etag[CEPH_CRYPTO_MD5_DIGESTSIZE];
char final_etag_str[CEPH_CRYPTO_MD5_DIGESTSIZE * 2 + 16];
std::string etag;
bufferlist etag_bl;
MD5 hash;
// Allow use of MD5 digest in FIPS mode for non-cryptographic purposes
hash.SetFlags(EVP_MD_CTX_FLAG_NON_FIPS_ALLOW);
bool truncated;
int rc;
ldpp_dout(dpp, 20) << "MotrMultipartUpload::complete(): enter" << dendl;
int total_parts = 0;
int handled_parts = 0;
int max_parts = 1000;
int marker = 0;
uint64_t min_part_size = cct->_conf->rgw_multipart_min_part_size;
auto etags_iter = part_etags.begin();
rgw::sal::Attrs attrs = target_obj->get_attrs();
do {
ldpp_dout(dpp, 20) << "MotrMultipartUpload::complete(): list_parts()" << dendl;
rc = list_parts(dpp, cct, max_parts, marker, &marker, &truncated);
if (rc == -ENOENT) {
rc = -ERR_NO_SUCH_UPLOAD;
}
if (rc < 0)
return rc;
total_parts += parts.size();
if (!truncated && total_parts != (int)part_etags.size()) {
ldpp_dout(dpp, 0) << "NOTICE: total parts mismatch: have: " << total_parts
<< " expected: " << part_etags.size() << dendl;
rc = -ERR_INVALID_PART;
return rc;
}
ldpp_dout(dpp, 20) << "MotrMultipartUpload::complete(): parts.size()=" << parts.size() << dendl;
for (auto obj_iter = parts.begin();
etags_iter != part_etags.end() && obj_iter != parts.end();
++etags_iter, ++obj_iter, ++handled_parts) {
MultipartPart *mpart = obj_iter->second.get();
MotrMultipartPart *mmpart = static_cast<MotrMultipartPart *>(mpart);
RGWUploadPartInfo *part = &mmpart->info;
uint64_t part_size = part->accounted_size;
ldpp_dout(dpp, 20) << "MotrMultipartUpload::complete(): part_size=" << part_size << dendl;
if (handled_parts < (int)part_etags.size() - 1 &&
part_size < min_part_size) {
rc = -ERR_TOO_SMALL;
return rc;
}
char petag[CEPH_CRYPTO_MD5_DIGESTSIZE];
if (etags_iter->first != (int)obj_iter->first) {
ldpp_dout(dpp, 0) << "NOTICE: parts num mismatch: next requested: "
<< etags_iter->first << " next uploaded: "
<< obj_iter->first << dendl;
rc = -ERR_INVALID_PART;
return rc;
}
string part_etag = rgw_string_unquote(etags_iter->second);
if (part_etag.compare(part->etag) != 0) {
ldpp_dout(dpp, 0) << "NOTICE: etag mismatch: part: " << etags_iter->first
<< " etag: " << etags_iter->second << dendl;
rc = -ERR_INVALID_PART;
return rc;
}
hex_to_buf(part->etag.c_str(), petag, CEPH_CRYPTO_MD5_DIGESTSIZE);
hash.Update((const unsigned char *)petag, sizeof(petag));
ldpp_dout(dpp, 20) << "MotrMultipartUpload::complete(): calc etag " << dendl;
string oid = mp_obj.get_part(part->num);
rgw_obj src_obj;
src_obj.init_ns(bucket->get_key(), oid, mp_ns);
#if 0 // does Motr backend need it?
/* update manifest for part */
if (part->manifest.empty()) {
ldpp_dout(dpp, 0) << "ERROR: empty manifest for object part: obj="
<< src_obj << dendl;
rc = -ERR_INVALID_PART;
return rc;
} else {
manifest.append(dpp, part->manifest, store->get_zone());
}
ldpp_dout(dpp, 0) << "MotrMultipartUpload::complete(): manifest " << dendl;
#endif
bool part_compressed = (part->cs_info.compression_type != "none");
if ((handled_parts > 0) &&
((part_compressed != compressed) ||
(cs_info.compression_type != part->cs_info.compression_type))) {
ldpp_dout(dpp, 0) << "ERROR: compression type was changed during multipart upload ("
<< cs_info.compression_type << ">>" << part->cs_info.compression_type << ")" << dendl;
rc = -ERR_INVALID_PART;
return rc;
}
ldpp_dout(dpp, 20) << "MotrMultipartUpload::complete(): part compression" << dendl;
if (part_compressed) {
int64_t new_ofs; // offset in compression data for new part
if (cs_info.blocks.size() > 0)
new_ofs = cs_info.blocks.back().new_ofs + cs_info.blocks.back().len;
else
new_ofs = 0;
for (const auto& block : part->cs_info.blocks) {
compression_block cb;
cb.old_ofs = block.old_ofs + cs_info.orig_size;
cb.new_ofs = new_ofs;
cb.len = block.len;
cs_info.blocks.push_back(cb);
new_ofs = cb.new_ofs + cb.len;
}
if (!compressed)
cs_info.compression_type = part->cs_info.compression_type;
cs_info.orig_size += part->cs_info.orig_size;
compressed = true;
}
// We may not need to do the following as remove_objs are those
// don't show when listing a bucket. As we store in-progress uploaded
// object's metadata in a separate index, they are not shown when
// listing a bucket.
rgw_obj_index_key remove_key;
src_obj.key.get_index_key(&remove_key);
remove_objs.push_back(remove_key);
off += part_size;
accounted_size += part->accounted_size;
ldpp_dout(dpp, 20) << "MotrMultipartUpload::complete(): off=" << off << ", accounted_size = " << accounted_size << dendl;
}
} while (truncated);
hash.Final((unsigned char *)final_etag);
buf_to_hex((unsigned char *)final_etag, sizeof(final_etag), final_etag_str);
snprintf(&final_etag_str[CEPH_CRYPTO_MD5_DIGESTSIZE * 2],
sizeof(final_etag_str) - CEPH_CRYPTO_MD5_DIGESTSIZE * 2,
"-%lld", (long long)part_etags.size());
etag = final_etag_str;
ldpp_dout(dpp, 20) << "calculated etag: " << etag << dendl;
etag_bl.append(etag);
attrs[RGW_ATTR_ETAG] = etag_bl;
if (compressed) {
// write compression attribute to full object
bufferlist tmp;
encode(cs_info, tmp);
attrs[RGW_ATTR_COMPRESSION] = tmp;
}
// Read the object's the multipart_upload_info.
// TODO: all those index name and key constructions should be implemented as
// member functions.
bufferlist bl;
std::unique_ptr<rgw::sal::Object> meta_obj;
meta_obj = get_meta_obj();
string bucket_multipart_iname =
"motr.rgw.bucket." + meta_obj->get_bucket()->get_name() + ".multiparts";
rc = this->store->do_idx_op_by_name(bucket_multipart_iname,
M0_IC_GET, meta_obj->get_key().get_oid(), bl);
ldpp_dout(dpp, 20) << "MotrMultipartUpload::complete(): read entry from bucket multipart index rc=" << rc << dendl;
if (rc < 0)
return rc;
rgw_bucket_dir_entry ent;
bufferlist& blr = bl;
auto ent_iter = blr.cbegin();
ent.decode(ent_iter);
// Update the dir entry and insert it to the bucket index so
// the object will be seen when listing the bucket.
bufferlist update_bl;
target_obj->get_key().get_index_key(&ent.key); // Change to offical name :)
ent.meta.size = off;
ent.meta.accounted_size = accounted_size;
ldpp_dout(dpp, 20) << "MotrMultipartUpload::complete(): obj size=" << ent.meta.size
<< " obj accounted size=" << ent.meta.accounted_size << dendl;
ent.meta.mtime = ceph::real_clock::now();
ent.meta.etag = etag;
ent.encode(update_bl);
encode(attrs, update_bl);
MotrObject::Meta meta_dummy;
meta_dummy.encode(update_bl);
string bucket_index_iname = "motr.rgw.bucket.index." + meta_obj->get_bucket()->get_name();
ldpp_dout(dpp, 20) << "MotrMultipartUpload::complete(): target_obj name=" << target_obj->get_name()
<< " target_obj oid=" << target_obj->get_oid() << dendl;
rc = store->do_idx_op_by_name(bucket_index_iname, M0_IC_PUT,
target_obj->get_name(), update_bl);
if (rc < 0)
return rc;
// Put into metadata cache.
store->get_obj_meta_cache()->put(dpp, target_obj->get_name(), update_bl);
// Now we can remove it from bucket multipart index.
ldpp_dout(dpp, 20) << "MotrMultipartUpload::complete(): remove from bucket multipartindex " << dendl;
return store->do_idx_op_by_name(bucket_multipart_iname,
M0_IC_DEL, meta_obj->get_key().get_oid(), bl);
}
int MotrMultipartUpload::get_info(const DoutPrefixProvider *dpp, optional_yield y, rgw_placement_rule** rule, rgw::sal::Attrs* attrs)
{
if (!rule && !attrs) {
return 0;
}
if (rule) {
if (!placement.empty()) {
*rule = &placement;
if (!attrs) {
/* Don't need attrs, done */
return 0;
}
} else {
*rule = nullptr;
}
}
std::unique_ptr<rgw::sal::Object> meta_obj;
meta_obj = get_meta_obj();
meta_obj->set_in_extra_data(true);
// Read the object's the multipart_upload_info.
bufferlist bl;
string bucket_multipart_iname =
"motr.rgw.bucket." + meta_obj->get_bucket()->get_name() + ".multiparts";
int rc = this->store->do_idx_op_by_name(bucket_multipart_iname,
M0_IC_GET, meta_obj->get_key().get_oid(), bl);
if (rc < 0) {
ldpp_dout(dpp, 0) << __func__ << ": Failed to get multipart info. rc=" << rc << dendl;
return rc == -ENOENT ? -ERR_NO_SUCH_UPLOAD : rc;
}
rgw_bucket_dir_entry ent;
bufferlist& blr = bl;
auto ent_iter = blr.cbegin();
ent.decode(ent_iter);
if (attrs) {
bufferlist etag_bl;
string& etag = ent.meta.etag;
ldpp_dout(dpp, 20) << "object's etag: " << ent.meta.etag << dendl;
etag_bl.append(etag.c_str(), etag.size());
attrs->emplace(std::move(RGW_ATTR_ETAG), std::move(etag_bl));
if (!rule || *rule != nullptr) {
/* placement was cached; don't actually read */
return 0;
}
}
/* Decode multipart_upload_info */
motr_multipart_upload_info upload_info;
bufferlist mpbl;
mpbl.append(ent.meta.user_data.c_str(), ent.meta.user_data.size());
auto mpbl_iter = mpbl.cbegin();
upload_info.decode(mpbl_iter);
placement = upload_info.dest_placement;
*rule = &placement;
return 0;
}
std::unique_ptr<Writer> MotrMultipartUpload::get_writer(
const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num,
const std::string& part_num_str)
{
return std::make_unique<MotrMultipartWriter>(dpp, y, this,
obj, store, owner,
ptail_placement_rule, part_num, part_num_str);
}
int MotrMultipartWriter::prepare(optional_yield y)
{
string part_obj_name = head_obj->get_bucket()->get_name() + "." +
head_obj->get_key().get_oid() +
".part." + std::to_string(part_num);
ldpp_dout(dpp, 20) << "bucket=" << head_obj->get_bucket()->get_name() << "part_obj_name=" << part_obj_name << dendl;
part_obj = std::make_unique<MotrObject>(this->store, rgw_obj_key(part_obj_name), head_obj->get_bucket());
if (part_obj == nullptr)
return -ENOMEM;
// s3 client may retry uploading part, so the part may have already
// been created.
int rc = part_obj->create_mobj(dpp, store->cctx->_conf->rgw_max_chunk_size);
if (rc == -EEXIST) {
rc = part_obj->open_mobj(dpp);
if (rc < 0)
return rc;
}
return rc;
}
int MotrMultipartWriter::process(bufferlist&& data, uint64_t offset)
{
int rc = part_obj->write_mobj(dpp, std::move(data), offset);
if (rc == 0) {
actual_part_size += data.length();
ldpp_dout(dpp, 20) << " write_mobj(): actual_part_size=" << actual_part_size << dendl;
}
return rc;
}
int MotrMultipartWriter::complete(size_t accounted_size, const std::string& etag,
ceph::real_time *mtime, ceph::real_time set_mtime,
std::map<std::string, bufferlist>& attrs,
ceph::real_time delete_at,
const char *if_match, const char *if_nomatch,
const std::string *user_data,
rgw_zone_set *zones_trace, bool *canceled,
optional_yield y)
{
// Should the dir entry(object metadata) be updated? For example
// mtime.
ldpp_dout(dpp, 20) << "MotrMultipartWriter::complete(): enter" << dendl;
// Add an entry into object_nnn_part_index.
bufferlist bl;
RGWUploadPartInfo info;
info.num = part_num;
info.etag = etag;
info.size = actual_part_size;
info.accounted_size = accounted_size;
info.modified = real_clock::now();
bool compressed;
int rc = rgw_compression_info_from_attrset(attrs, compressed, info.cs_info);
ldpp_dout(dpp, 20) << "MotrMultipartWriter::complete(): compression rc=" << rc << dendl;
if (rc < 0) {
ldpp_dout(dpp, 1) << "cannot get compression info" << dendl;
return rc;
}
encode(info, bl);
encode(attrs, bl);
part_obj->meta.encode(bl);
string p = "part.";
char buf[32];
snprintf(buf, sizeof(buf), "%08d", (int)part_num);
p.append(buf);
string obj_part_iname = "motr.rgw.object." + head_obj->get_bucket()->get_name() + "." +
head_obj->get_key().get_oid() + ".parts";
ldpp_dout(dpp, 20) << "MotrMultipartWriter::complete(): object part index = " << obj_part_iname << dendl;
rc = store->do_idx_op_by_name(obj_part_iname, M0_IC_PUT, p, bl);
if (rc < 0) {
return rc == -ENOENT ? -ERR_NO_SUCH_UPLOAD : rc;
}
return 0;
}
std::unique_ptr<RGWRole> MotrStore::get_role(std::string name,
std::string tenant,
std::string path,
std::string trust_policy,
std::string max_session_duration_str,
std::multimap<std::string,std::string> tags)
{
RGWRole* p = nullptr;
return std::unique_ptr<RGWRole>(p);
}
std::unique_ptr<RGWRole> MotrStore::get_role(const RGWRoleInfo& info)
{
RGWRole* p = nullptr;
return std::unique_ptr<RGWRole>(p);
}
std::unique_ptr<RGWRole> MotrStore::get_role(std::string id)
{
RGWRole* p = nullptr;
return std::unique_ptr<RGWRole>(p);
}
int MotrStore::get_roles(const DoutPrefixProvider *dpp,
optional_yield y,
const std::string& path_prefix,
const std::string& tenant,
vector<std::unique_ptr<RGWRole>>& roles)
{
return 0;
}
std::unique_ptr<RGWOIDCProvider> MotrStore::get_oidc_provider()
{
RGWOIDCProvider* p = nullptr;
return std::unique_ptr<RGWOIDCProvider>(p);
}
int MotrStore::get_oidc_providers(const DoutPrefixProvider *dpp,
const std::string& tenant,
vector<std::unique_ptr<RGWOIDCProvider>>& providers)
{
return 0;
}
std::unique_ptr<MultipartUpload> MotrBucket::get_multipart_upload(const std::string& oid,
std::optional<std::string> upload_id,
ACLOwner owner, ceph::real_time mtime)
{
return std::make_unique<MotrMultipartUpload>(store, this, oid, upload_id, owner, mtime);
}
std::unique_ptr<Writer> MotrStore::get_append_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
const std::string& unique_tag,
uint64_t position,
uint64_t *cur_accounted_size) {
return nullptr;
}
std::unique_ptr<Writer> MotrStore::get_atomic_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag) {
return std::make_unique<MotrAtomicWriter>(dpp, y,
obj, this, owner,
ptail_placement_rule, olh_epoch, unique_tag);
}
const std::string& MotrStore::get_compression_type(const rgw_placement_rule& rule)
{
return zone.zone_params->get_compression_type(rule);
}
bool MotrStore::valid_placement(const rgw_placement_rule& rule)
{
return zone.zone_params->valid_placement(rule);
}
std::unique_ptr<User> MotrStore::get_user(const rgw_user &u)
{
ldout(cctx, 20) << "bucket's user: " << u.to_str() << dendl;
return std::make_unique<MotrUser>(this, u);
}
int MotrStore::get_user_by_access_key(const DoutPrefixProvider *dpp, const std::string &key, optional_yield y, std::unique_ptr<User> *user)
{
int rc;
User *u;
bufferlist bl;
RGWUserInfo uinfo;
MotrAccessKey access_key;
rc = do_idx_op_by_name(RGW_IAM_MOTR_ACCESS_KEY,
M0_IC_GET, key, bl);
if (rc < 0){
ldout(cctx, 0) << "Access key not found: rc = " << rc << dendl;
return rc;
}
bufferlist& blr = bl;
auto iter = blr.cbegin();
access_key.decode(iter);
uinfo.user_id.from_str(access_key.user_id);
ldout(cctx, 0) << "Loading user: " << uinfo.user_id.id << dendl;
rc = MotrUser().load_user_from_idx(dpp, this, uinfo, nullptr, nullptr);
if (rc < 0){
ldout(cctx, 0) << "Failed to load user: rc = " << rc << dendl;
return rc;
}
u = new MotrUser(this, uinfo);
if (!u)
return -ENOMEM;
user->reset(u);
return 0;
}
int MotrStore::get_user_by_email(const DoutPrefixProvider *dpp, const std::string& email, optional_yield y, std::unique_ptr<User>* user)
{
int rc;
User *u;
bufferlist bl;
RGWUserInfo uinfo;
MotrEmailInfo email_info;
rc = do_idx_op_by_name(RGW_IAM_MOTR_EMAIL_KEY,
M0_IC_GET, email, bl);
if (rc < 0){
ldout(cctx, 0) << "Email Id not found: rc = " << rc << dendl;
return rc;
}
auto iter = bl.cbegin();
email_info.decode(iter);
ldout(cctx, 0) << "Loading user: " << email_info.user_id << dendl;
uinfo.user_id.from_str(email_info.user_id);
rc = MotrUser().load_user_from_idx(dpp, this, uinfo, nullptr, nullptr);
if (rc < 0){
ldout(cctx, 0) << "Failed to load user: rc = " << rc << dendl;
return rc;
}
u = new MotrUser(this, uinfo);
if (!u)
return -ENOMEM;
user->reset(u);
return 0;
}
int MotrStore::get_user_by_swift(const DoutPrefixProvider *dpp, const std::string& user_str, optional_yield y, std::unique_ptr<User>* user)
{
/* Swift keys and subusers are not supported for now */
return 0;
}
int MotrStore::store_access_key(const DoutPrefixProvider *dpp, optional_yield y, MotrAccessKey access_key)
{
int rc;
bufferlist bl;
access_key.encode(bl);
rc = do_idx_op_by_name(RGW_IAM_MOTR_ACCESS_KEY,
M0_IC_PUT, access_key.id, bl);
if (rc < 0){
ldout(cctx, 0) << "Failed to store key: rc = " << rc << dendl;
return rc;
}
return rc;
}
int MotrStore::delete_access_key(const DoutPrefixProvider *dpp, optional_yield y, std::string access_key)
{
int rc;
bufferlist bl;
rc = do_idx_op_by_name(RGW_IAM_MOTR_ACCESS_KEY,
M0_IC_DEL, access_key, bl);
if (rc < 0){
ldout(cctx, 0) << "Failed to delete key: rc = " << rc << dendl;
}
return rc;
}
int MotrStore::store_email_info(const DoutPrefixProvider *dpp, optional_yield y, MotrEmailInfo& email_info )
{
int rc;
bufferlist bl;
email_info.encode(bl);
rc = do_idx_op_by_name(RGW_IAM_MOTR_EMAIL_KEY,
M0_IC_PUT, email_info.email_id, bl);
if (rc < 0) {
ldout(cctx, 0) << "Failed to store the user by email as key: rc = " << rc << dendl;
}
return rc;
}
std::unique_ptr<Object> MotrStore::get_object(const rgw_obj_key& k)
{
return std::make_unique<MotrObject>(this, k);
}
int MotrStore::get_bucket(const DoutPrefixProvider *dpp, User* u, const rgw_bucket& b, std::unique_ptr<Bucket>* bucket, optional_yield y)
{
int ret;
Bucket* bp;
bp = new MotrBucket(this, b, u);
ret = bp->load_bucket(dpp, y);
if (ret < 0) {
delete bp;
return ret;
}
bucket->reset(bp);
return 0;
}
int MotrStore::get_bucket(User* u, const RGWBucketInfo& i, std::unique_ptr<Bucket>* bucket)
{
Bucket* bp;
bp = new MotrBucket(this, i, u);
/* Don't need to fetch the bucket info, use the provided one */
bucket->reset(bp);
return 0;
}
int MotrStore::get_bucket(const DoutPrefixProvider *dpp, User* u, const std::string& tenant, const std::string& name, std::unique_ptr<Bucket>* bucket, optional_yield y)
{
rgw_bucket b;
b.tenant = tenant;
b.name = name;
return get_bucket(dpp, u, b, bucket, y);
}
bool MotrStore::is_meta_master()
{
return true;
}
int MotrStore::forward_request_to_master(const DoutPrefixProvider *dpp, User* user, obj_version *objv,
bufferlist& in_data,
JSONParser *jp, req_info& info,
optional_yield y)
{
return 0;
}
int MotrStore::forward_iam_request_to_master(const DoutPrefixProvider *dpp, const RGWAccessKey& key, obj_version* objv,
bufferlist& in_data,
RGWXMLDecoder::XMLParser* parser, req_info& info,
optional_yield y)
{
return 0;
}
std::string MotrStore::zone_unique_id(uint64_t unique_num)
{
return "";
}
std::string MotrStore::zone_unique_trans_id(const uint64_t unique_num)
{
return "";
}
int MotrStore::get_zonegroup(const std::string& id, std::unique_ptr<ZoneGroup>* group)
{
/* XXX: for now only one zonegroup supported */
ZoneGroup* zg;
zg = new MotrZoneGroup(this, zone.zonegroup.get_group());
group->reset(zg);
return 0;
}
int MotrStore::list_all_zones(const DoutPrefixProvider* dpp,
std::list<std::string>& zone_ids)
{
zone_ids.push_back(zone.get_id());
return 0;
}
int MotrStore::cluster_stat(RGWClusterStat& stats)
{
return 0;
}
std::unique_ptr<Lifecycle> MotrStore::get_lifecycle(void)
{
return 0;
}
std::unique_ptr<Notification> MotrStore::get_notification(Object* obj, Object* src_obj, req_state* s,
rgw::notify::EventType event_type, optional_yield y, const string* object_name)
{
return std::make_unique<MotrNotification>(obj, src_obj, event_type);
}
std::unique_ptr<Notification> MotrStore::get_notification(const DoutPrefixProvider* dpp, Object* obj,
Object* src_obj, rgw::notify::EventType event_type, rgw::sal::Bucket* _bucket,
std::string& _user_id, std::string& _user_tenant, std::string& _req_id, optional_yield y)
{
return std::make_unique<MotrNotification>(obj, src_obj, event_type);
}
int MotrStore::log_usage(const DoutPrefixProvider *dpp, map<rgw_user_bucket, RGWUsageBatch>& usage_info)
{
return 0;
}
int MotrStore::log_op(const DoutPrefixProvider *dpp, string& oid, bufferlist& bl)
{
return 0;
}
int MotrStore::register_to_service_map(const DoutPrefixProvider *dpp, const string& daemon_type,
const map<string, string>& meta)
{
return 0;
}
void MotrStore::get_ratelimit(RGWRateLimitInfo& bucket_ratelimit,
RGWRateLimitInfo& user_ratelimit,
RGWRateLimitInfo& anon_ratelimit)
{
return;
}
void MotrStore::get_quota(RGWQuota& quota)
{
// XXX: Not handled for the first pass
return;
}
int MotrStore::set_buckets_enabled(const DoutPrefixProvider *dpp, vector<rgw_bucket>& buckets, bool enabled)
{
return 0;
}
int MotrStore::get_sync_policy_handler(const DoutPrefixProvider *dpp,
std::optional<rgw_zone_id> zone,
std::optional<rgw_bucket> bucket,
RGWBucketSyncPolicyHandlerRef *phandler,
optional_yield y)
{
return 0;
}
RGWDataSyncStatusManager* MotrStore::get_data_sync_manager(const rgw_zone_id& source_zone)
{
return 0;
}
int MotrStore::read_all_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch,
uint32_t max_entries, bool *is_truncated,
RGWUsageIter& usage_iter,
map<rgw_user_bucket, rgw_usage_log_entry>& usage)
{
return 0;
}
int MotrStore::trim_all_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch)
{
return 0;
}
int MotrStore::get_config_key_val(string name, bufferlist *bl)
{
return 0;
}
int MotrStore::meta_list_keys_init(const DoutPrefixProvider *dpp, const string& section, const string& marker, void** phandle)
{
return 0;
}
int MotrStore::meta_list_keys_next(const DoutPrefixProvider *dpp, void* handle, int max, list<string>& keys, bool* truncated)
{
return 0;
}
void MotrStore::meta_list_keys_complete(void* handle)
{
return;
}
std::string MotrStore::meta_get_marker(void* handle)
{
return "";
}
int MotrStore::meta_remove(const DoutPrefixProvider *dpp, string& metadata_key, optional_yield y)
{
return 0;
}
int MotrStore::open_idx(struct m0_uint128 *id, bool create, struct m0_idx *idx)
{
m0_idx_init(idx, &container.co_realm, id);
if (!create)
return 0; // nothing to do more
// create index or make sure it's created
struct m0_op *op = nullptr;
int rc = m0_entity_create(nullptr, &idx->in_entity, &op);
if (rc != 0) {
ldout(cctx, 0) << "ERROR: m0_entity_create() failed: " << rc << dendl;
goto out;
}
m0_op_launch(&op, 1);
rc = m0_op_wait(op, M0_BITS(M0_OS_FAILED, M0_OS_STABLE), M0_TIME_NEVER) ?:
m0_rc(op);
m0_op_fini(op);
m0_op_free(op);
if (rc != 0 && rc != -EEXIST)
ldout(cctx, 0) << "ERROR: index create failed: " << rc << dendl;
out:
return rc;
}
static void set_m0bufvec(struct m0_bufvec *bv, vector<uint8_t>& vec)
{
*bv->ov_buf = reinterpret_cast<char*>(vec.data());
*bv->ov_vec.v_count = vec.size();
}
// idx must be opened with open_idx() beforehand
int MotrStore::do_idx_op(struct m0_idx *idx, enum m0_idx_opcode opcode,
vector<uint8_t>& key, vector<uint8_t>& val, bool update)
{
int rc, rc_i;
struct m0_bufvec k, v, *vp = &v;
uint32_t flags = 0;
struct m0_op *op = nullptr;
if (m0_bufvec_empty_alloc(&k, 1) != 0) {
ldout(cctx, 0) << "ERROR: failed to allocate key bufvec" << dendl;
return -ENOMEM;
}
if (opcode == M0_IC_PUT || opcode == M0_IC_GET) {
rc = -ENOMEM;
if (m0_bufvec_empty_alloc(&v, 1) != 0) {
ldout(cctx, 0) << "ERROR: failed to allocate value bufvec" << dendl;
goto out;
}
}
set_m0bufvec(&k, key);
if (opcode == M0_IC_PUT)
set_m0bufvec(&v, val);
if (opcode == M0_IC_DEL)
vp = nullptr;
if (opcode == M0_IC_PUT && update)
flags |= M0_OIF_OVERWRITE;
rc = m0_idx_op(idx, opcode, &k, vp, &rc_i, flags, &op);
if (rc != 0) {
ldout(cctx, 0) << "ERROR: failed to init index op: " << rc << dendl;
goto out;
}
m0_op_launch(&op, 1);
rc = m0_op_wait(op, M0_BITS(M0_OS_FAILED, M0_OS_STABLE), M0_TIME_NEVER) ?:
m0_rc(op);
m0_op_fini(op);
m0_op_free(op);
if (rc != 0) {
ldout(cctx, 0) << "ERROR: op failed: " << rc << dendl;
goto out;
}
if (rc_i != 0) {
ldout(cctx, 0) << "ERROR: idx op failed: " << rc_i << dendl;
rc = rc_i;
goto out;
}
if (opcode == M0_IC_GET) {
val.resize(*v.ov_vec.v_count);
memcpy(reinterpret_cast<char*>(val.data()), *v.ov_buf, *v.ov_vec.v_count);
}
out:
m0_bufvec_free2(&k);
if (opcode == M0_IC_GET)
m0_bufvec_free(&v); // cleanup buffer after GET
else if (opcode == M0_IC_PUT)
m0_bufvec_free2(&v);
return rc;
}
// Retrieve a range of key/value pairs starting from keys[0].
int MotrStore::do_idx_next_op(struct m0_idx *idx,
vector<vector<uint8_t>>& keys,
vector<vector<uint8_t>>& vals)
{
int rc;
uint32_t i = 0;
int nr_kvp = vals.size();
int *rcs = new int[nr_kvp];
struct m0_bufvec k, v;
struct m0_op *op = nullptr;
rc = m0_bufvec_empty_alloc(&k, nr_kvp)?:
m0_bufvec_empty_alloc(&v, nr_kvp);
if (rc != 0) {
ldout(cctx, 0) << "ERROR: failed to allocate kv bufvecs" << dendl;
return rc;
}
set_m0bufvec(&k, keys[0]);
rc = m0_idx_op(idx, M0_IC_NEXT, &k, &v, rcs, 0, &op);
if (rc != 0) {
ldout(cctx, 0) << "ERROR: failed to init index op: " << rc << dendl;
goto out;
}
m0_op_launch(&op, 1);
rc = m0_op_wait(op, M0_BITS(M0_OS_FAILED, M0_OS_STABLE), M0_TIME_NEVER) ?:
m0_rc(op);
m0_op_fini(op);
m0_op_free(op);
if (rc != 0) {
ldout(cctx, 0) << "ERROR: op failed: " << rc << dendl;
goto out;
}
for (i = 0; i < v.ov_vec.v_nr; ++i) {
if (rcs[i] < 0)
break;
vector<uint8_t>& key = keys[i];
vector<uint8_t>& val = vals[i];
key.resize(k.ov_vec.v_count[i]);
val.resize(v.ov_vec.v_count[i]);
memcpy(reinterpret_cast<char*>(key.data()), k.ov_buf[i], k.ov_vec.v_count[i]);
memcpy(reinterpret_cast<char*>(val.data()), v.ov_buf[i], v.ov_vec.v_count[i]);
}
out:
k.ov_vec.v_nr = i;
v.ov_vec.v_nr = i;
m0_bufvec_free(&k);
m0_bufvec_free(&v); // cleanup buffer after GET
delete []rcs;
return rc ?: i;
}
// Retrieve a number of key/value pairs under the prefix starting
// from the marker at key_out[0].
int MotrStore::next_query_by_name(string idx_name,
vector<string>& key_out,
vector<bufferlist>& val_out,
string prefix, string delim)
{
unsigned nr_kvp = std::min(val_out.size(), 100UL);
struct m0_idx idx = {};
vector<vector<uint8_t>> keys(nr_kvp);
vector<vector<uint8_t>> vals(nr_kvp);
struct m0_uint128 idx_id;
int i = 0, j, k = 0;
index_name_to_motr_fid(idx_name, &idx_id);
int rc = open_motr_idx(&idx_id, &idx);
if (rc != 0) {
ldout(cctx, 0) << "ERROR: next_query_by_name(): failed to open index: rc="
<< rc << dendl;
goto out;
}
// Only the first element for keys needs to be set for NEXT query.
// The keys will be set will the returned keys from motr index.
ldout(cctx, 20) <<__func__<< ": next_query_by_name(): index=" << idx_name
<< " prefix=" << prefix << " delim=" << delim << dendl;
keys[0].assign(key_out[0].begin(), key_out[0].end());
for (i = 0; i < (int)val_out.size(); i += k, k = 0) {
rc = do_idx_next_op(&idx, keys, vals);
ldout(cctx, 20) << "do_idx_next_op() = " << rc << dendl;
if (rc < 0) {
ldout(cctx, 0) << "ERROR: NEXT query failed. " << rc << dendl;
goto out;
}
string dir;
for (j = 0, k = 0; j < rc; ++j) {
string key(keys[j].begin(), keys[j].end());
size_t pos = std::string::npos;
if (!delim.empty())
pos = key.find(delim, prefix.length());
if (pos != std::string::npos) { // DIR entry
dir.assign(key, 0, pos + 1);
if (dir.compare(0, prefix.length(), prefix) != 0)
goto out;
if (i + k == 0 || dir != key_out[i + k - 1]) // a new one
key_out[i + k++] = dir;
continue;
}
dir = "";
if (key.compare(0, prefix.length(), prefix) != 0)
goto out;
key_out[i + k] = key;
bufferlist& vbl = val_out[i + k];
vbl.append(reinterpret_cast<char*>(vals[j].data()), vals[j].size());
++k;
}
if (rc < (int)nr_kvp) // there are no more keys to fetch
break;
string next_key;
if (dir != "")
next_key = dir + "\xff"; // skip all dir content in 1 step
else
next_key = key_out[i + k - 1] + " ";
ldout(cctx, 0) << "do_idx_next_op(): next_key=" << next_key << dendl;
keys[0].assign(next_key.begin(), next_key.end());
}
out:
m0_idx_fini(&idx);
return rc < 0 ? rc : i + k;
}
int MotrStore::delete_motr_idx_by_name(string iname)
{
struct m0_idx idx;
struct m0_uint128 idx_id;
struct m0_op *op = nullptr;
ldout(cctx, 20) << "delete_motr_idx_by_name=" << iname << dendl;
index_name_to_motr_fid(iname, &idx_id);
m0_idx_init(&idx, &container.co_realm, &idx_id);
m0_entity_open(&idx.in_entity, &op);
int rc = m0_entity_delete(&idx.in_entity, &op);
if (rc < 0)
goto out;
m0_op_launch(&op, 1);
ldout(cctx, 70) << "waiting for op completion" << dendl;
rc = m0_op_wait(op, M0_BITS(M0_OS_FAILED, M0_OS_STABLE), M0_TIME_NEVER) ?:
m0_rc(op);
m0_op_fini(op);
m0_op_free(op);
if (rc == -ENOENT) // race deletion??
rc = 0;
else if (rc < 0)
ldout(cctx, 0) << "ERROR: index create failed: " << rc << dendl;
ldout(cctx, 20) << "delete_motr_idx_by_name rc=" << rc << dendl;
out:
m0_idx_fini(&idx);
return rc;
}
int MotrStore::open_motr_idx(struct m0_uint128 *id, struct m0_idx *idx)
{
m0_idx_init(idx, &container.co_realm, id);
return 0;
}
// The following marcos are from dix/fid_convert.h which are not exposed.
enum {
M0_DIX_FID_DEVICE_ID_OFFSET = 32,
M0_DIX_FID_DIX_CONTAINER_MASK = (1ULL << M0_DIX_FID_DEVICE_ID_OFFSET)
- 1,
};
// md5 is used here, a more robust way to convert index name to fid is
// needed to avoid collision.
void MotrStore::index_name_to_motr_fid(string iname, struct m0_uint128 *id)
{
unsigned char md5[16]; // 128/8 = 16
MD5 hash;
// Allow use of MD5 digest in FIPS mode for non-cryptographic purposes
hash.SetFlags(EVP_MD_CTX_FLAG_NON_FIPS_ALLOW);
hash.Update((const unsigned char *)iname.c_str(), iname.length());
hash.Final(md5);
memcpy(&id->u_hi, md5, 8);
memcpy(&id->u_lo, md5 + 8, 8);
ldout(cctx, 20) << "id = 0x" << std::hex << id->u_hi << ":0x" << std::hex << id->u_lo << dendl;
struct m0_fid *fid = (struct m0_fid*)id;
m0_fid_tset(fid, m0_dix_fid_type.ft_id,
fid->f_container & M0_DIX_FID_DIX_CONTAINER_MASK, fid->f_key);
ldout(cctx, 20) << "converted id = 0x" << std::hex << id->u_hi << ":0x" << std::hex << id->u_lo << dendl;
}
int MotrStore::do_idx_op_by_name(string idx_name, enum m0_idx_opcode opcode,
string key_str, bufferlist &bl, bool update)
{
struct m0_idx idx;
vector<uint8_t> key(key_str.begin(), key_str.end());
vector<uint8_t> val;
struct m0_uint128 idx_id;
index_name_to_motr_fid(idx_name, &idx_id);
int rc = open_motr_idx(&idx_id, &idx);
if (rc != 0) {
ldout(cctx, 0) << "ERROR: failed to open index: " << rc << dendl;
goto out;
}
if (opcode == M0_IC_PUT)
val.assign(bl.c_str(), bl.c_str() + bl.length());
ldout(cctx, 20) <<__func__<< ": do_idx_op_by_name(): op="
<< (opcode == M0_IC_PUT ? "PUT" : "GET")
<< " idx=" << idx_name << " key=" << key_str << dendl;
rc = do_idx_op(&idx, opcode, key, val, update);
if (rc == 0 && opcode == M0_IC_GET)
// Append the returned value (blob) to the bufferlist.
bl.append(reinterpret_cast<char*>(val.data()), val.size());
out:
m0_idx_fini(&idx);
return rc;
}
int MotrStore::create_motr_idx_by_name(string iname)
{
struct m0_idx idx = {};
struct m0_uint128 id;
index_name_to_motr_fid(iname, &id);
m0_idx_init(&idx, &container.co_realm, &id);
// create index or make sure it's created
struct m0_op *op = nullptr;
int rc = m0_entity_create(nullptr, &idx.in_entity, &op);
if (rc != 0) {
ldout(cctx, 0) << "ERROR: m0_entity_create() failed: " << rc << dendl;
goto out;
}
m0_op_launch(&op, 1);
rc = m0_op_wait(op, M0_BITS(M0_OS_FAILED, M0_OS_STABLE), M0_TIME_NEVER) ?:
m0_rc(op);
m0_op_fini(op);
m0_op_free(op);
if (rc != 0 && rc != -EEXIST)
ldout(cctx, 0) << "ERROR: index create failed: " << rc << dendl;
out:
m0_idx_fini(&idx);
return rc;
}
// If a global index is checked (if it has been create) every time
// before they're queried (put/get), which takes 2 Motr operations to
// complete the query. As the global indices' name and FID are known
// already when MotrStore is created, we move the check and creation
// in newMotrStore().
// Similar method is used for per bucket/user index. For example,
// bucket instance index is created when creating the bucket.
int MotrStore::check_n_create_global_indices()
{
int rc = 0;
for (const auto& iname : motr_global_indices) {
rc = create_motr_idx_by_name(iname);
if (rc < 0 && rc != -EEXIST)
break;
rc = 0;
}
return rc;
}
std::string MotrStore::get_cluster_id(const DoutPrefixProvider* dpp, optional_yield y)
{
char id[M0_FID_STR_LEN];
struct m0_confc *confc = m0_reqh2confc(&instance->m0c_reqh);
m0_fid_print(id, ARRAY_SIZE(id), &confc->cc_root->co_id);
return std::string(id);
}
int MotrStore::init_metadata_cache(const DoutPrefixProvider *dpp,
CephContext *cct)
{
this->obj_meta_cache = new MotrMetaCache(dpp, cct);
this->get_obj_meta_cache()->set_enabled(true);
this->user_cache = new MotrMetaCache(dpp, cct);
this->get_user_cache()->set_enabled(true);
this->bucket_inst_cache = new MotrMetaCache(dpp, cct);
this->get_bucket_inst_cache()->set_enabled(true);
return 0;
}
int MotrLuaManager::get_script(const DoutPrefixProvider* dpp, optional_yield y, const std::string& key, std::string& script)
{
return -ENOENT;
}
int MotrLuaManager::put_script(const DoutPrefixProvider* dpp, optional_yield y, const std::string& key, const std::string& script)
{
return -ENOENT;
}
int MotrLuaManager::del_script(const DoutPrefixProvider* dpp, optional_yield y, const std::string& key)
{
return -ENOENT;
}
int MotrLuaManager::add_package(const DoutPrefixProvider* dpp, optional_yield y, const std::string& package_name)
{
return -ENOENT;
}
int MotrLuaManager::remove_package(const DoutPrefixProvider* dpp, optional_yield y, const std::string& package_name)
{
return -ENOENT;
}
int MotrLuaManager::list_packages(const DoutPrefixProvider* dpp, optional_yield y, rgw::lua::packages_t& packages)
{
return -ENOENT;
}
} // namespace rgw::sal
extern "C" {
void *newMotrStore(CephContext *cct)
{
int rc = -1;
rgw::sal::MotrStore *store = new rgw::sal::MotrStore(cct);
if (store) {
store->conf.mc_is_oostore = true;
// XXX: these params should be taken from config settings and
// cct somehow?
store->instance = nullptr;
const auto& proc_ep = g_conf().get_val<std::string>("motr_my_endpoint");
const auto& ha_ep = g_conf().get_val<std::string>("motr_ha_endpoint");
const auto& proc_fid = g_conf().get_val<std::string>("motr_my_fid");
const auto& profile = g_conf().get_val<std::string>("motr_profile_fid");
const auto& admin_proc_ep = g_conf().get_val<std::string>("motr_admin_endpoint");
const auto& admin_proc_fid = g_conf().get_val<std::string>("motr_admin_fid");
const int init_flags = cct->get_init_flags();
ldout(cct, 0) << "INFO: motr my endpoint: " << proc_ep << dendl;
ldout(cct, 0) << "INFO: motr ha endpoint: " << ha_ep << dendl;
ldout(cct, 0) << "INFO: motr my fid: " << proc_fid << dendl;
ldout(cct, 0) << "INFO: motr profile fid: " << profile << dendl;
store->conf.mc_local_addr = proc_ep.c_str();
store->conf.mc_process_fid = proc_fid.c_str();
ldout(cct, 0) << "INFO: init flags: " << init_flags << dendl;
ldout(cct, 0) << "INFO: motr admin endpoint: " << admin_proc_ep << dendl;
ldout(cct, 0) << "INFO: motr admin fid: " << admin_proc_fid << dendl;
// HACK this is so that radosge-admin uses a different client
if (init_flags == 0) {
store->conf.mc_process_fid = admin_proc_fid.c_str();
store->conf.mc_local_addr = admin_proc_ep.c_str();
} else {
store->conf.mc_process_fid = proc_fid.c_str();
store->conf.mc_local_addr = proc_ep.c_str();
}
store->conf.mc_ha_addr = ha_ep.c_str();
store->conf.mc_profile = profile.c_str();
ldout(cct, 50) << "INFO: motr profile fid: " << store->conf.mc_profile << dendl;
ldout(cct, 50) << "INFO: ha addr: " << store->conf.mc_ha_addr << dendl;
ldout(cct, 50) << "INFO: process fid: " << store->conf.mc_process_fid << dendl;
ldout(cct, 50) << "INFO: motr endpoint: " << store->conf.mc_local_addr << dendl;
store->conf.mc_tm_recv_queue_min_len = 64;
store->conf.mc_max_rpc_msg_size = 524288;
store->conf.mc_idx_service_id = M0_IDX_DIX;
store->dix_conf.kc_create_meta = false;
store->conf.mc_idx_service_conf = &store->dix_conf;
if (!g_conf().get_val<bool>("motr_tracing_enabled")) {
m0_trace_level_allow(M0_WARN); // allow errors and warnings in syslog anyway
m0_trace_set_mmapped_buffer(false);
}
store->instance = nullptr;
rc = m0_client_init(&store->instance, &store->conf, true);
if (rc != 0) {
ldout(cct, 0) << "ERROR: m0_client_init() failed: " << rc << dendl;
goto out;
}
m0_container_init(&store->container, nullptr, &M0_UBER_REALM, store->instance);
rc = store->container.co_realm.re_entity.en_sm.sm_rc;
if (rc != 0) {
ldout(cct, 0) << "ERROR: m0_container_init() failed: " << rc << dendl;
goto out;
}
rc = m0_ufid_init(store->instance, &ufid_gr);
if (rc != 0) {
ldout(cct, 0) << "ERROR: m0_ufid_init() failed: " << rc << dendl;
goto out;
}
// Create global indices if not yet.
rc = store->check_n_create_global_indices();
if (rc != 0) {
ldout(cct, 0) << "ERROR: check_n_create_global_indices() failed: " << rc << dendl;
goto out;
}
}
out:
if (rc != 0) {
delete store;
return nullptr;
}
return store;
}
}
| 123,860 | 29.957511 | 178 |
cc
|
null |
ceph-main/src/rgw/rgw_sal_motr.h
|
// vim: ts=2 sw=2 expandtab ft=cpp
/*
* Ceph - scalable distributed file system
*
* SAL implementation for the CORTX Motr backend
*
* Copyright (C) 2021 Seagate Technology LLC and/or its Affiliates
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#pragma once
extern "C" {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wextern-c-compat"
#pragma clang diagnostic ignored "-Wdeprecated-anon-enum-enum-conversion"
#include "motr/config.h"
#include "motr/client.h"
#pragma clang diagnostic pop
}
#include "rgw_sal_store.h"
#include "rgw_rados.h"
#include "rgw_notify.h"
#include "rgw_oidc_provider.h"
#include "rgw_role.h"
#include "rgw_multi.h"
#include "rgw_putobj_processor.h"
namespace rgw::sal {
class MotrStore;
// Global Motr indices
#define RGW_MOTR_USERS_IDX_NAME "motr.rgw.users"
#define RGW_MOTR_BUCKET_INST_IDX_NAME "motr.rgw.bucket.instances"
#define RGW_MOTR_BUCKET_HD_IDX_NAME "motr.rgw.bucket.headers"
#define RGW_IAM_MOTR_ACCESS_KEY "motr.rgw.accesskeys"
#define RGW_IAM_MOTR_EMAIL_KEY "motr.rgw.emails"
//#define RGW_MOTR_BUCKET_ACL_IDX_NAME "motr.rgw.bucket.acls"
// A simplified metadata cache implementation.
// Note: MotrObjMetaCache doesn't handle the IO operations to Motr. A proxy
// class can be added to handle cache and 'real' ops.
class MotrMetaCache
{
protected:
// MGW re-uses ObjectCache to cache object's metadata as it has already
// implemented a lru cache: (1) ObjectCache internally uses a map and lru
// list to manage cache entry. POC uses object name, user name or bucket
// name as the key to lookup and insert an entry. (2) ObjectCache::data is
// a bufferlist and can be used to store any metadata structure, such as
// object's bucket dir entry, user info or bucket instance.
//
// Note from RGW:
// The Rados Gateway stores metadata and objects in an internal cache. This
// should be kept consistent by the OSD's relaying notify events between
// multiple watching RGW processes. In the event that this notification
// protocol fails, bounding the length of time that any data in the cache will
// be assumed valid will ensure that any RGW instance that falls out of sync
// will eventually recover. This seems to be an issue mostly for large numbers
// of RGW instances under heavy use. If you would like to turn off cache expiry,
// set this value to zero.
//
// Currently POC hasn't implemented the watch-notify menchanism yet. So the
// current implementation is similar to cortx-s3server which is based on expiry
// time. TODO: see comments on distribute_cache).
//
// Beaware: Motr object data is not cached in current POC as RGW!
// RGW caches the first chunk (4MB by default).
ObjectCache cache;
public:
// Lookup a cache entry.
int get(const DoutPrefixProvider *dpp, const std::string& name, bufferlist& data);
// Insert a cache entry.
int put(const DoutPrefixProvider *dpp, const std::string& name, const bufferlist& data);
// Called when an object is deleted. Notification should be sent to other
// RGW instances.
int remove(const DoutPrefixProvider *dpp, const std::string& name);
// Make the local cache entry invalid.
void invalid(const DoutPrefixProvider *dpp, const std::string& name);
// TODO: Distribute_cache() and watch_cb() now are only place holder functions.
// Checkout services/svc_sys_obj_cache.h/cc for reference.
// These 2 functions are designed to notify or to act on cache notification.
// It is feasible to implement the functionality using Motr's FDMI after discussing
// with Hua.
int distribute_cache(const DoutPrefixProvider *dpp,
const std::string& normal_name,
ObjectCacheInfo& obj_info, int op);
int watch_cb(const DoutPrefixProvider *dpp,
uint64_t notify_id,
uint64_t cookie,
uint64_t notifier_id,
bufferlist& bl);
void set_enabled(bool status);
MotrMetaCache(const DoutPrefixProvider *dpp, CephContext *cct) {
cache.set_ctx(cct);
}
};
struct MotrUserInfo {
RGWUserInfo info;
obj_version user_version;
rgw::sal::Attrs attrs;
void encode(bufferlist& bl) const
{
ENCODE_START(3, 3, bl);
encode(info, bl);
encode(user_version, bl);
encode(attrs, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl)
{
DECODE_START(3, bl);
decode(info, bl);
decode(user_version, bl);
decode(attrs, bl);
DECODE_FINISH(bl);
}
};
WRITE_CLASS_ENCODER(MotrUserInfo);
struct MotrEmailInfo {
std::string user_id;
std::string email_id;
MotrEmailInfo() {}
MotrEmailInfo(std::string _user_id, std::string _email_id )
: user_id(std::move(_user_id)), email_id(std::move(_email_id)) {}
void encode(bufferlist& bl) const {
ENCODE_START(2, 2, bl);
encode(user_id, bl);
encode(email_id, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START_LEGACY_COMPAT_LEN_32(2, 2, 2, bl);
decode(user_id, bl);
decode(email_id, bl);
DECODE_FINISH(bl);
}
};
WRITE_CLASS_ENCODER(MotrEmailInfo);
struct MotrAccessKey {
std::string id; // AccessKey
std::string key; // SecretKey
std::string user_id; // UserID
MotrAccessKey() {}
MotrAccessKey(std::string _id, std::string _key, std::string _user_id)
: id(std::move(_id)), key(std::move(_key)), user_id(std::move(_user_id)) {}
void encode(bufferlist& bl) const {
ENCODE_START(2, 2, bl);
encode(id, bl);
encode(key, bl);
encode(user_id, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START_LEGACY_COMPAT_LEN_32(2, 2, 2, bl);
decode(id, bl);
decode(key, bl);
decode(user_id, bl);
DECODE_FINISH(bl);
}
};
WRITE_CLASS_ENCODER(MotrAccessKey);
class MotrNotification : public StoreNotification {
public:
MotrNotification(Object* _obj, Object* _src_obj, rgw::notify::EventType _type) :
StoreNotification(_obj, _src_obj, _type) {}
~MotrNotification() = default;
virtual int publish_reserve(const DoutPrefixProvider *dpp, RGWObjTags* obj_tags = nullptr) override { return 0;}
virtual int publish_commit(const DoutPrefixProvider* dpp, uint64_t size,
const ceph::real_time& mtime, const std::string& etag, const std::string& version) override { return 0; }
};
class MotrUser : public StoreUser {
private:
MotrStore *store;
struct m0_uint128 idxID = {0xe5ecb53640d4ecce, 0x6a156cd5a74aa3b8}; // MD5 of “motr.rgw.users“
struct m0_idx idx;
public:
std::set<std::string> access_key_tracker;
MotrUser(MotrStore *_st, const rgw_user& _u) : StoreUser(_u), store(_st) { }
MotrUser(MotrStore *_st, const RGWUserInfo& _i) : StoreUser(_i), store(_st) { }
MotrUser(MotrStore *_st) : store(_st) { }
MotrUser(MotrUser& _o) = default;
MotrUser() {}
virtual std::unique_ptr<User> clone() override {
return std::unique_ptr<User>(new MotrUser(*this));
}
int list_buckets(const DoutPrefixProvider *dpp, const std::string& marker, const std::string& end_marker,
uint64_t max, bool need_stats, BucketList& buckets, optional_yield y) override;
virtual int create_bucket(const DoutPrefixProvider* dpp,
const rgw_bucket& b,
const std::string& zonegroup_id,
rgw_placement_rule& placement_rule,
std::string& swift_ver_location,
const RGWQuotaInfo* pquota_info,
const RGWAccessControlPolicy& policy,
Attrs& attrs,
RGWBucketInfo& info,
obj_version& ep_objv,
bool exclusive,
bool obj_lock_enabled,
bool* existed,
req_info& req_info,
std::unique_ptr<Bucket>* bucket,
optional_yield y) override;
virtual int read_attrs(const DoutPrefixProvider* dpp, optional_yield y) override;
virtual int merge_and_store_attrs(const DoutPrefixProvider* dpp, Attrs& new_attrs, optional_yield y) override;
virtual int read_stats(const DoutPrefixProvider *dpp,
optional_yield y, RGWStorageStats* stats,
ceph::real_time *last_stats_sync = nullptr,
ceph::real_time *last_stats_update = nullptr) override;
virtual int read_stats_async(const DoutPrefixProvider *dpp, RGWGetUserStats_CB* cb) override;
virtual int complete_flush_stats(const DoutPrefixProvider *dpp, optional_yield y) override;
virtual int read_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch, uint32_t max_entries,
bool* is_truncated, RGWUsageIter& usage_iter,
std::map<rgw_user_bucket, rgw_usage_log_entry>& usage) override;
virtual int trim_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch) override;
virtual int load_user(const DoutPrefixProvider* dpp, optional_yield y) override;
virtual int store_user(const DoutPrefixProvider* dpp, optional_yield y, bool exclusive, RGWUserInfo* old_info = nullptr) override;
virtual int remove_user(const DoutPrefixProvider* dpp, optional_yield y) override;
virtual int verify_mfa(const std::string& mfa_str, bool* verified, const DoutPrefixProvider* dpp, optional_yield y) override;
int create_user_info_idx();
int load_user_from_idx(const DoutPrefixProvider *dpp, MotrStore *store, RGWUserInfo& info, std::map<std::string,
bufferlist> *attrs, RGWObjVersionTracker *objv_tr);
friend class MotrBucket;
};
class MotrBucket : public StoreBucket {
private:
MotrStore *store;
RGWAccessControlPolicy acls;
// RGWBucketInfo and other information that are shown when listing a bucket is
// represented in struct MotrBucketInfo. The structure is encoded and stored
// as the value of the global bucket instance index.
// TODO: compare pros and cons of separating the bucket_attrs (ACLs, tag etc.)
// into a different index.
struct MotrBucketInfo {
RGWBucketInfo info;
obj_version bucket_version;
ceph::real_time mtime;
rgw::sal::Attrs bucket_attrs;
void encode(bufferlist& bl) const
{
ENCODE_START(4, 4, bl);
encode(info, bl);
encode(bucket_version, bl);
encode(mtime, bl);
encode(bucket_attrs, bl); //rgw_cache.h example for a map
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl)
{
DECODE_START(4, bl);
decode(info, bl);
decode(bucket_version, bl);
decode(mtime, bl);
decode(bucket_attrs, bl);
DECODE_FINISH(bl);
}
};
WRITE_CLASS_ENCODER(MotrBucketInfo);
public:
MotrBucket(MotrStore *_st)
: store(_st),
acls() {
}
MotrBucket(MotrStore *_st, User* _u)
: StoreBucket(_u),
store(_st),
acls() {
}
MotrBucket(MotrStore *_st, const rgw_bucket& _b)
: StoreBucket(_b),
store(_st),
acls() {
}
MotrBucket(MotrStore *_st, const RGWBucketEnt& _e)
: StoreBucket(_e),
store(_st),
acls() {
}
MotrBucket(MotrStore *_st, const RGWBucketInfo& _i)
: StoreBucket(_i),
store(_st),
acls() {
}
MotrBucket(MotrStore *_st, const rgw_bucket& _b, User* _u)
: StoreBucket(_b, _u),
store(_st),
acls() {
}
MotrBucket(MotrStore *_st, const RGWBucketEnt& _e, User* _u)
: StoreBucket(_e, _u),
store(_st),
acls() {
}
MotrBucket(MotrStore *_st, const RGWBucketInfo& _i, User* _u)
: StoreBucket(_i, _u),
store(_st),
acls() {
}
~MotrBucket() { }
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;
virtual int remove_bucket(const DoutPrefixProvider *dpp, bool delete_children, bool forward_to_master, req_info* req_info, optional_yield y) override;
virtual int remove_bucket_bypass_gc(int concurrent_max, bool
keep_index_consistent,
optional_yield y, const
DoutPrefixProvider *dpp) override;
virtual RGWAccessControlPolicy& get_acl(void) override { return acls; }
virtual int set_acl(const DoutPrefixProvider *dpp, RGWAccessControlPolicy& acl, optional_yield y) override;
virtual int load_bucket(const DoutPrefixProvider *dpp, optional_yield y, bool get_stats = false) override;
int link_user(const DoutPrefixProvider* dpp, User* new_user, optional_yield y);
int unlink_user(const DoutPrefixProvider* dpp, User* new_user, optional_yield y);
int create_bucket_index();
int create_multipart_indices();
virtual int read_stats(const DoutPrefixProvider *dpp,
const bucket_index_layout_generation& idx_layout, int shard_id,
std::string *bucket_ver, std::string *master_ver,
std::map<RGWObjCategory, RGWStorageStats>& stats,
std::string *max_marker = nullptr,
bool *syncstopped = nullptr) override;
virtual int read_stats_async(const DoutPrefixProvider *dpp,
const bucket_index_layout_generation& idx_layout,
int shard_id, RGWGetBucketStats_CB* ctx) override;
virtual int sync_user_stats(const DoutPrefixProvider *dpp, optional_yield y) override;
virtual int update_container_stats(const DoutPrefixProvider *dpp) override;
virtual int check_bucket_shards(const DoutPrefixProvider *dpp) override;
virtual int chown(const DoutPrefixProvider *dpp, User& new_user, optional_yield y) override;
virtual int put_info(const DoutPrefixProvider *dpp, bool exclusive, ceph::real_time mtime) override;
virtual bool is_owner(User* user) 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 merge_and_store_attrs(const DoutPrefixProvider *dpp, Attrs& attrs, optional_yield y) override;
virtual int try_refresh_info(const DoutPrefixProvider *dpp, ceph::real_time *pmtime) override;
virtual int read_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch, uint32_t max_entries,
bool *is_truncated, RGWUsageIter& usage_iter,
std::map<rgw_user_bucket, rgw_usage_log_entry>& usage) override;
virtual int trim_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch) override;
virtual int remove_objs_from_index(const DoutPrefixProvider *dpp, std::list<rgw_obj_index_key>& objs_to_unlink) override;
virtual int check_index(const DoutPrefixProvider *dpp, std::map<RGWObjCategory, RGWStorageStats>& existing_stats, std::map<RGWObjCategory, RGWStorageStats>& calculated_stats) override;
virtual int rebuild_index(const DoutPrefixProvider *dpp) override;
virtual int set_tag_timeout(const DoutPrefixProvider *dpp, uint64_t timeout) override;
virtual int purge_instance(const DoutPrefixProvider *dpp) override;
virtual std::unique_ptr<Bucket> clone() override {
return std::make_unique<MotrBucket>(*this);
}
virtual std::unique_ptr<MultipartUpload> get_multipart_upload(const std::string& oid,
std::optional<std::string> upload_id=std::nullopt,
ACLOwner owner={}, ceph::real_time mtime=real_clock::now()) override;
virtual int list_multiparts(const DoutPrefixProvider *dpp,
const std::string& prefix,
std::string& marker,
const std::string& delim,
const int& max_uploads,
std::vector<std::unique_ptr<MultipartUpload>>& uploads,
std::map<std::string, bool> *common_prefixes,
bool *is_truncated) override;
virtual int abort_multiparts(const DoutPrefixProvider *dpp, CephContext *cct) override;
friend class MotrStore;
};
class MotrPlacementTier: public StorePlacementTier {
MotrStore* store;
RGWZoneGroupPlacementTier tier;
public:
MotrPlacementTier(MotrStore* _store, const RGWZoneGroupPlacementTier& _tier) : store(_store), tier(_tier) {}
virtual ~MotrPlacementTier() = default;
virtual const std::string& get_tier_type() { return tier.tier_type; }
virtual const std::string& get_storage_class() { return tier.storage_class; }
virtual bool retain_head_object() { return tier.retain_head_object; }
RGWZoneGroupPlacementTier& get_rt() { return tier; }
};
class MotrZoneGroup : public StoreZoneGroup {
MotrStore* store;
const RGWZoneGroup group;
std::string empty;
public:
MotrZoneGroup(MotrStore* _store) : store(_store), group() {}
MotrZoneGroup(MotrStore* _store, const RGWZoneGroup& _group) : store(_store), group(_group) {}
virtual ~MotrZoneGroup() = default;
virtual const std::string& get_id() const override { return group.get_id(); };
virtual const std::string& get_name() const override { return group.get_name(); };
virtual int equals(const std::string& other_zonegroup) const override {
return group.equals(other_zonegroup);
};
/** Get the endpoint from zonegroup, or from master zone if not set */
virtual const std::string& get_endpoint() const override;
virtual bool placement_target_exists(std::string& target) const override;
virtual bool is_master_zonegroup() const override {
return group.is_master_zonegroup();
};
virtual const std::string& get_api_name() const override { return group.api_name; };
virtual int get_placement_target_names(std::set<std::string>& names) const override;
virtual const std::string& get_default_placement_name() const override {
return group.default_placement.name; };
virtual int get_hostnames(std::list<std::string>& names) const override {
names = group.hostnames;
return 0;
};
virtual int get_s3website_hostnames(std::list<std::string>& names) const override {
names = group.hostnames_s3website;
return 0;
};
virtual int get_zone_count() const override {
return group.zones.size();
}
virtual int get_placement_tier(const rgw_placement_rule& rule, std::unique_ptr<PlacementTier>* tier);
virtual int get_zone_by_id(const std::string& id, std::unique_ptr<Zone>* zone) override {
return -1;
}
virtual int get_zone_by_name(const std::string& name, std::unique_ptr<Zone>* zone) override {
return -1;
}
virtual int list_zones(std::list<std::string>& zone_ids) override {
zone_ids.clear();
return 0;
}
const RGWZoneGroup& get_group() { return group; }
virtual std::unique_ptr<ZoneGroup> clone() override {
return std::make_unique<MotrZoneGroup>(store, group);
}
};
class MotrZone : public StoreZone {
protected:
MotrStore* store;
RGWRealm *realm{nullptr};
MotrZoneGroup zonegroup;
RGWZone *zone_public_config{nullptr}; /* external zone params, e.g., entrypoints, log flags, etc. */
RGWZoneParams *zone_params{nullptr}; /* internal zone params, e.g., rados pools */
RGWPeriod *current_period{nullptr};
public:
MotrZone(MotrStore* _store) : store(_store), zonegroup(_store) {
realm = new RGWRealm();
zone_public_config = new RGWZone();
zone_params = new RGWZoneParams();
current_period = new RGWPeriod();
// XXX: only default and STANDARD supported for now
RGWZonePlacementInfo info;
RGWZoneStorageClasses sc;
sc.set_storage_class("STANDARD", nullptr, nullptr);
info.storage_classes = sc;
zone_params->placement_pools["default"] = info;
}
MotrZone(MotrStore* _store, MotrZoneGroup _zg) : store(_store), zonegroup(_zg) {
realm = new RGWRealm();
// TODO: fetch zonegroup params (eg. id) from provisioner config.
zonegroup.set_id("0956b174-fe14-4f97-8b50-bb7ec5e1cf62");
zonegroup.api_name = "default";
zone_public_config = new RGWZone();
zone_params = new RGWZoneParams();
current_period = new RGWPeriod();
// XXX: only default and STANDARD supported for now
RGWZonePlacementInfo info;
RGWZoneStorageClasses sc;
sc.set_storage_class("STANDARD", nullptr, nullptr);
info.storage_classes = sc;
zone_params->placement_pools["default"] = info;
}
~MotrZone() = default;
virtual std::unique_ptr<Zone> clone() override {
return std::make_unique<MotrZone>(store);
}
virtual ZoneGroup& get_zonegroup() override;
virtual const std::string& get_id() override;
virtual const std::string& get_name() const override;
virtual bool is_writeable() override;
virtual bool get_redirect_endpoint(std::string* endpoint) override;
virtual bool has_zonegroup_api(const std::string& api) const override;
virtual const std::string& get_current_period_id() override;
virtual const RGWAccessKey& get_system_key() { return zone_params->system_key; }
virtual const std::string& get_realm_name() { return realm->get_name(); }
virtual const std::string& get_realm_id() { return realm->get_id(); }
virtual const std::string_view get_tier_type() { return "rgw"; }
virtual RGWBucketSyncPolicyHandlerRef get_sync_policy_handler() { return nullptr; }
friend class MotrStore;
};
class MotrLuaManager : public StoreLuaManager {
MotrStore* store;
public:
MotrLuaManager(MotrStore* _s) : store(_s)
{
}
virtual ~MotrLuaManager() = default;
/** Get a script named with the given key from the backing store */
virtual int get_script(const DoutPrefixProvider* dpp, optional_yield y, const std::string& key, std::string& script) override;
/** Put a script named with the given key to the backing store */
virtual int put_script(const DoutPrefixProvider* dpp, optional_yield y, const std::string& key, const std::string& script) override;
/** Delete a script named with the given key from the backing store */
virtual int del_script(const DoutPrefixProvider* dpp, optional_yield y, const std::string& key) override;
/** Add a lua package */
virtual int add_package(const DoutPrefixProvider* dpp, optional_yield y, const std::string& package_name) override;
/** Remove a lua package */
virtual int remove_package(const DoutPrefixProvider* dpp, optional_yield y, const std::string& package_name) override;
/** List lua packages */
virtual int list_packages(const DoutPrefixProvider* dpp, optional_yield y, rgw::lua::packages_t& packages) override;
};
class MotrOIDCProvider : public RGWOIDCProvider {
MotrStore* store;
public:
MotrOIDCProvider(MotrStore* _store) : store(_store) {}
~MotrOIDCProvider() = default;
virtual int store_url(const DoutPrefixProvider *dpp, const std::string& url, bool exclusive, optional_yield y) override { return 0; }
virtual int read_url(const DoutPrefixProvider *dpp, const std::string& url, const std::string& tenant) override { return 0; }
virtual int delete_obj(const DoutPrefixProvider *dpp, optional_yield y) override { return 0;}
void encode(bufferlist& bl) const {
RGWOIDCProvider::encode(bl);
}
void decode(bufferlist::const_iterator& bl) {
RGWOIDCProvider::decode(bl);
}
};
class MotrObject : public StoreObject {
private:
MotrStore *store;
RGWAccessControlPolicy acls;
RGWObjCategory category;
// If this object is pat of a multipart uploaded one.
// TODO: do it in another class? MotrPartObject : public MotrObject
uint64_t part_off;
uint64_t part_size;
uint64_t part_num;
public:
// motr object metadata stored in index
struct Meta {
struct m0_uint128 oid = {};
struct m0_fid pver = {};
uint64_t layout_id = 0;
void encode(bufferlist& bl) const
{
ENCODE_START(5, 5, bl);
encode(oid.u_hi, bl);
encode(oid.u_lo, bl);
encode(pver.f_container, bl);
encode(pver.f_key, bl);
encode(layout_id, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl)
{
DECODE_START(5, bl);
decode(oid.u_hi, bl);
decode(oid.u_lo, bl);
decode(pver.f_container, bl);
decode(pver.f_key, bl);
decode(layout_id, bl);
DECODE_FINISH(bl);
}
};
struct m0_obj *mobj = NULL;
Meta meta;
struct MotrReadOp : public ReadOp {
private:
MotrObject* source;
// The set of part objects if the source is
// a multipart uploaded object.
std::map<int, std::unique_ptr<MotrObject>> part_objs;
public:
MotrReadOp(MotrObject *_source);
virtual int prepare(optional_yield y, const DoutPrefixProvider* dpp) override;
/*
* Both `read` and `iterate` read up through index `end`
* *inclusive*. The number of bytes that could be returned is
* `end - ofs + 1`.
*/
virtual int read(int64_t off, int64_t end, bufferlist& bl,
optional_yield y,
const DoutPrefixProvider* dpp) override;
virtual int iterate(const DoutPrefixProvider* dpp, int64_t off,
int64_t end, RGWGetDataCB* cb,
optional_yield y) override;
virtual int get_attr(const DoutPrefixProvider* dpp, const char* name, bufferlist& dest, optional_yield y) override;
};
struct MotrDeleteOp : public DeleteOp {
private:
MotrObject* source;
public:
MotrDeleteOp(MotrObject* _source);
virtual int delete_obj(const DoutPrefixProvider* dpp, optional_yield y) override;
};
MotrObject() = default;
MotrObject(MotrStore *_st, const rgw_obj_key& _k)
: StoreObject(_k), store(_st), acls() {}
MotrObject(MotrStore *_st, const rgw_obj_key& _k, Bucket* _b)
: StoreObject(_k, _b), store(_st), acls() {}
MotrObject(MotrObject& _o) = default;
virtual ~MotrObject();
virtual int delete_object(const DoutPrefixProvider* dpp,
optional_yield y,
bool prevent_versioning = false) override;
virtual int copy_object(User* user,
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,
const ceph::real_time* mod_ptr, const ceph::real_time* unmod_ptr,
bool high_precision_time,
const char* if_match, const char* if_nomatch,
AttrsMod attrs_mod, bool copy_if_newer, Attrs& attrs,
RGWObjCategory category, uint64_t olh_epoch,
boost::optional<ceph::real_time> delete_at,
std::string* version_id, std::string* tag, std::string* etag,
void (*progress_cb)(off_t, void *), void* progress_data,
const DoutPrefixProvider* dpp, optional_yield y) override;
virtual RGWAccessControlPolicy& get_acl(void) override { return acls; }
virtual int set_acl(const RGWAccessControlPolicy& acl) override { acls = acl; return 0; }
virtual int get_obj_state(const DoutPrefixProvider* dpp, RGWObjState **state, optional_yield y, bool follow_olh = true) override;
virtual int set_obj_attrs(const DoutPrefixProvider* dpp, Attrs* setattrs, Attrs* delattrs, optional_yield y) override;
virtual int get_obj_attrs(optional_yield y, const DoutPrefixProvider* dpp, rgw_obj* target_obj = NULL) override;
virtual int modify_obj_attrs(const char* attr_name, bufferlist& attr_val, optional_yield y, const DoutPrefixProvider* dpp) override;
virtual int delete_obj_attrs(const DoutPrefixProvider* dpp, const char* attr_name, optional_yield y) override;
virtual bool is_expired() override;
virtual void gen_rand_obj_instance_name() override;
virtual std::unique_ptr<Object> clone() override {
return std::unique_ptr<Object>(new MotrObject(*this));
}
virtual std::unique_ptr<MPSerializer> get_serializer(const DoutPrefixProvider *dpp, const std::string& lock_name) override;
virtual int transition(Bucket* bucket,
const rgw_placement_rule& placement_rule,
const real_time& mtime,
uint64_t olh_epoch,
const DoutPrefixProvider* dpp,
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;
/* Swift versioning */
virtual int swift_versioning_restore(bool& restored,
const DoutPrefixProvider* dpp) override;
virtual int swift_versioning_copy(const DoutPrefixProvider* dpp,
optional_yield y) override;
/* OPs */
virtual std::unique_ptr<ReadOp> get_read_op() override;
virtual std::unique_ptr<DeleteOp> get_delete_op() override;
/* OMAP */
virtual int omap_get_vals_by_keys(const DoutPrefixProvider *dpp, const std::string& oid,
const std::set<std::string>& keys,
Attrs* vals) override;
virtual int omap_set_val_by_key(const DoutPrefixProvider *dpp, const std::string& key, bufferlist& val,
bool must_exist, optional_yield y) override;
virtual int chown(User& new_user, const DoutPrefixProvider* dpp, optional_yield y) override;
private:
//int read_attrs(const DoutPrefixProvider* dpp, Motr::Object::Read &read_op, optional_yield y, rgw_obj* target_obj = nullptr);
public:
bool is_opened() { return mobj != NULL; }
int create_mobj(const DoutPrefixProvider *dpp, uint64_t sz);
int open_mobj(const DoutPrefixProvider *dpp);
int delete_mobj(const DoutPrefixProvider *dpp);
void close_mobj();
int write_mobj(const DoutPrefixProvider *dpp, bufferlist&& data, uint64_t offset);
int read_mobj(const DoutPrefixProvider* dpp, int64_t off, int64_t end, RGWGetDataCB* cb);
unsigned get_optimal_bs(unsigned len);
int get_part_objs(const DoutPrefixProvider *dpp,
std::map<int, std::unique_ptr<MotrObject>>& part_objs);
int open_part_objs(const DoutPrefixProvider* dpp,
std::map<int, std::unique_ptr<MotrObject>>& part_objs);
int read_multipart_obj(const DoutPrefixProvider* dpp,
int64_t off, int64_t end, RGWGetDataCB* cb,
std::map<int, std::unique_ptr<MotrObject>>& part_objs);
int delete_part_objs(const DoutPrefixProvider* dpp);
void set_category(RGWObjCategory _category) {category = _category;}
int get_bucket_dir_ent(const DoutPrefixProvider *dpp, rgw_bucket_dir_entry& ent);
int update_version_entries(const DoutPrefixProvider *dpp);
};
// A placeholder locking class for multipart upload.
// TODO: implement it using Motr object locks.
class MPMotrSerializer : public StoreMPSerializer {
public:
MPMotrSerializer(const DoutPrefixProvider *dpp, MotrStore* store, MotrObject* obj, const std::string& lock_name) {}
virtual int try_lock(const DoutPrefixProvider *dpp, utime_t dur, optional_yield y) override {return 0; }
virtual int unlock() override { return 0;}
};
class MotrAtomicWriter : public StoreWriter {
protected:
rgw::sal::MotrStore* store;
const rgw_user& owner;
const rgw_placement_rule *ptail_placement_rule;
uint64_t olh_epoch;
const std::string& unique_tag;
MotrObject obj;
MotrObject old_obj;
uint64_t total_data_size; // for total data being uploaded
bufferlist acc_data; // accumulated data
uint64_t acc_off; // accumulated data offset
struct m0_bufvec buf;
struct m0_bufvec attr;
struct m0_indexvec ext;
public:
MotrAtomicWriter(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
MotrStore* _store,
const rgw_user& _owner,
const rgw_placement_rule *_ptail_placement_rule,
uint64_t _olh_epoch,
const std::string& _unique_tag);
~MotrAtomicWriter() = default;
// prepare to start processing object data
virtual int prepare(optional_yield y) override;
// Process a bufferlist
virtual int process(bufferlist&& data, uint64_t offset) override;
int write();
// complete the operation and make its result visible to clients
virtual int complete(size_t accounted_size, const std::string& etag,
ceph::real_time *mtime, ceph::real_time set_mtime,
std::map<std::string, bufferlist>& attrs,
ceph::real_time delete_at,
const char *if_match, const char *if_nomatch,
const std::string *user_data,
rgw_zone_set *zones_trace, bool *canceled,
optional_yield y) override;
unsigned populate_bvec(unsigned len, bufferlist::iterator &bi);
void cleanup();
};
class MotrMultipartWriter : public StoreWriter {
protected:
rgw::sal::MotrStore* store;
// Head object.
rgw::sal::Object* head_obj;
// Part parameters.
const uint64_t part_num;
const std::string part_num_str;
std::unique_ptr<MotrObject> part_obj;
uint64_t actual_part_size = 0;
public:
MotrMultipartWriter(const DoutPrefixProvider *dpp,
optional_yield y, MultipartUpload* upload,
rgw::sal::Object* obj,
MotrStore* _store,
const rgw_user& 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),
part_num(_part_num), part_num_str(part_num_str)
{
}
~MotrMultipartWriter() = default;
// prepare to start processing object data
virtual int prepare(optional_yield y) override;
// Process a bufferlist
virtual int process(bufferlist&& data, uint64_t offset) override;
// complete the operation and make its result visible to clients
virtual int complete(size_t accounted_size, const std::string& etag,
ceph::real_time *mtime, ceph::real_time set_mtime,
std::map<std::string, bufferlist>& attrs,
ceph::real_time delete_at,
const char *if_match, const char *if_nomatch,
const std::string *user_data,
rgw_zone_set *zones_trace, bool *canceled,
optional_yield y) override;
};
// The implementation of multipart upload in POC roughly follows the
// cortx-s3server's design. Parts are stored in separate Motr objects.
// s3server uses a few auxiliary Motr indices to manage multipart
// related metadata: (1) Bucket multipart index (bucket_nnn_multipart_index)
// which contains metadata that answers questions such as which objects have
// started multipart upload and its upload id. This index is created during
// bucket creation. (2) Object part index (object_nnn_part_index) which stores
// metadata of a part's details (size, pvid, oid...). This index is created in
// MotrMultipartUpload::init(). (3) Extended metadata index
// (bucket_nnn_extended_metadata): once parts has been uploaded and their
// metadata saved in the part index, the user may issue multipart completion
// request. When processing the completion request, the parts are read from
// object part index and for each part an entry is created in extended index.
// The entry for the object is created in bucket (object list) index. The part
// index is deleted and an entry removed from bucket_nnn_multipart_index. Like
// bucket multipart index, bucket part extened metadata index is created during
// bucket creation.
//
// The extended metadata index is used mainly due to fault tolerant
// considerations (how to handle Motr service crash when uploading an object)
// and to avoid to create too many Motr indices (I am not sure I understand
// why many Motr indices is bad.). In our POC, to keep it simple, only 2
// indices are maintained: bucket multipart index and object_nnn_part_index.
//
//
class MotrMultipartPart : public StoreMultipartPart {
protected:
RGWUploadPartInfo info;
public:
MotrObject::Meta meta;
MotrMultipartPart(RGWUploadPartInfo _info, MotrObject::Meta _meta) :
info(_info), meta(_meta) {}
virtual ~MotrMultipartPart() = default;
virtual uint32_t get_num() { return info.num; }
virtual uint64_t get_size() { return info.accounted_size; }
virtual const std::string& get_etag() { return info.etag; }
virtual ceph::real_time& get_mtime() { return info.modified; }
RGWObjManifest& get_manifest() { return info.manifest; }
friend class MotrMultipartUpload;
};
class MotrMultipartUpload : public StoreMultipartUpload {
MotrStore* store;
RGWMPObj mp_obj;
ACLOwner owner;
ceph::real_time mtime;
rgw_placement_rule placement;
RGWObjManifest manifest;
public:
MotrMultipartUpload(MotrStore* _store, Bucket* _bucket, const std::string& oid,
std::optional<std::string> upload_id, ACLOwner _owner, ceph::real_time _mtime) :
StoreMultipartUpload(_bucket), store(_store), mp_obj(oid, upload_id), owner(_owner), mtime(_mtime) {}
virtual ~MotrMultipartUpload() = default;
virtual const std::string& get_meta() const { return mp_obj.get_meta(); }
virtual const std::string& get_key() const { return mp_obj.get_key(); }
virtual const std::string& get_upload_id() const { return mp_obj.get_upload_id(); }
virtual const ACLOwner& get_owner() const override { return owner; }
virtual ceph::real_time& get_mtime() { return mtime; }
virtual std::unique_ptr<rgw::sal::Object> get_meta_obj() override;
virtual int init(const DoutPrefixProvider* dpp, optional_yield y, ACLOwner& owner, rgw_placement_rule& dest_placement, rgw::sal::Attrs& attrs) override;
virtual int list_parts(const DoutPrefixProvider* dpp, CephContext* cct,
int num_parts, int marker,
int* next_marker, bool* truncated,
bool assume_unsorted = false) override;
virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct) override;
virtual int complete(const DoutPrefixProvider* dpp,
optional_yield y, CephContext* cct,
std::map<int, std::string>& part_etags,
std::list<rgw_obj_index_key>& remove_objs,
uint64_t& accounted_size, bool& compressed,
RGWCompressionInfo& cs_info, off_t& off,
std::string& tag, ACLOwner& owner,
uint64_t olh_epoch,
rgw::sal::Object* target_obj) override;
virtual int get_info(const DoutPrefixProvider *dpp, optional_yield y, rgw_placement_rule** rule, 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,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num,
const std::string& part_num_str) override;
int delete_parts(const DoutPrefixProvider *dpp);
};
class MotrStore : public StoreDriver {
private:
MotrZone zone;
RGWSyncModuleInstanceRef sync_module;
MotrMetaCache* obj_meta_cache;
MotrMetaCache* user_cache;
MotrMetaCache* bucket_inst_cache;
public:
CephContext *cctx;
struct m0_client *instance;
struct m0_container container;
struct m0_realm uber_realm;
struct m0_config conf = {};
struct m0_idx_dix_config dix_conf = {};
MotrStore(CephContext *c): zone(this), cctx(c) {}
~MotrStore() {
delete obj_meta_cache;
delete user_cache;
delete bucket_inst_cache;
}
virtual int initialize(CephContext *cct, const DoutPrefixProvider *dpp) { return 0; }
virtual const std::string get_name() const override {
return "motr";
}
virtual std::unique_ptr<User> get_user(const rgw_user& u) override;
virtual std::string get_cluster_id(const DoutPrefixProvider* dpp, optional_yield y) override;
virtual int get_user_by_access_key(const DoutPrefixProvider *dpp, const std::string& key, optional_yield y, std::unique_ptr<User>* user) override;
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;
virtual int get_bucket(const DoutPrefixProvider *dpp, User* u, const rgw_bucket& b, std::unique_ptr<Bucket>* bucket, optional_yield y) override;
virtual int get_bucket(User* u, const RGWBucketInfo& i, std::unique_ptr<Bucket>* bucket) override;
virtual int get_bucket(const DoutPrefixProvider *dpp, User* u, const std::string& tenant, const std::string&name, std::unique_ptr<Bucket>* bucket, optional_yield y) override;
virtual bool is_meta_master() override;
virtual int forward_request_to_master(const DoutPrefixProvider *dpp, User* user, obj_version* objv,
bufferlist& in_data, JSONParser *jp, req_info& info,
optional_yield y) override;
virtual int forward_iam_request_to_master(const DoutPrefixProvider *dpp, const RGWAccessKey& key, obj_version* objv,
bufferlist& in_data,
RGWXMLDecoder::XMLParser* parser, req_info& info,
optional_yield y) override;
virtual Zone* get_zone() { return &zone; }
virtual std::string zone_unique_id(uint64_t unique_num) override;
virtual std::string zone_unique_trans_id(const uint64_t unique_num) override;
virtual int get_zonegroup(const std::string& id, std::unique_ptr<ZoneGroup>* zonegroup) override;
virtual int list_all_zones(const DoutPrefixProvider* dpp, std::list<std::string>& zone_ids) override;
virtual int cluster_stat(RGWClusterStat& stats) override;
virtual std::unique_ptr<Lifecycle> get_lifecycle(void) override;
virtual std::unique_ptr<Notification> get_notification(rgw::sal::Object* obj, rgw::sal::Object* src_obj,
req_state* s, rgw::notify::EventType event_type, optional_yield y, const std::string* object_name=nullptr) override;
virtual std::unique_ptr<Notification> get_notification(const DoutPrefixProvider* dpp, rgw::sal::Object* obj,
rgw::sal::Object* src_obj, rgw::notify::EventType event_type, rgw::sal::Bucket* _bucket,
std::string& _user_id, std::string& _user_tenant, std::string& _req_id, optional_yield y) override;
virtual RGWLC* get_rgwlc(void) override { return NULL; }
virtual RGWCoroutinesManagerRegistry* get_cr_registry() override { return NULL; }
virtual int log_usage(const DoutPrefixProvider *dpp, std::map<rgw_user_bucket, RGWUsageBatch>& usage_info) override;
virtual int log_op(const DoutPrefixProvider *dpp, std::string& oid, bufferlist& bl) override;
virtual int register_to_service_map(const DoutPrefixProvider *dpp, const std::string& daemon_type,
const std::map<std::string, std::string>& meta) override;
virtual void get_ratelimit(RGWRateLimitInfo& bucket_ratelimit, RGWRateLimitInfo& user_ratelimit, RGWRateLimitInfo& anon_ratelimit) override;
virtual void get_quota(RGWQuota& quota) override;
virtual int set_buckets_enabled(const DoutPrefixProvider *dpp, std::vector<rgw_bucket>& buckets, bool enabled) override;
virtual int get_sync_policy_handler(const DoutPrefixProvider *dpp,
std::optional<rgw_zone_id> zone,
std::optional<rgw_bucket> bucket,
RGWBucketSyncPolicyHandlerRef *phandler,
optional_yield y) override;
virtual RGWDataSyncStatusManager* get_data_sync_manager(const rgw_zone_id& source_zone) override;
virtual void wakeup_meta_sync_shards(std::set<int>& shard_ids) override { return; }
virtual void wakeup_data_sync_shards(const DoutPrefixProvider *dpp, const rgw_zone_id& source_zone, boost::container::flat_map<int, boost::container::flat_set<rgw_data_notify_entry>>& shard_ids) override {}
virtual int clear_usage(const DoutPrefixProvider *dpp) override { return 0; }
virtual int read_all_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch,
uint32_t max_entries, bool *is_truncated,
RGWUsageIter& usage_iter,
std::map<rgw_user_bucket, rgw_usage_log_entry>& usage) override;
virtual int trim_all_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch) override;
virtual int get_config_key_val(std::string name, bufferlist* bl) override;
virtual int meta_list_keys_init(const DoutPrefixProvider *dpp, const std::string& section, const std::string& marker, void** phandle) override;
virtual int meta_list_keys_next(const DoutPrefixProvider *dpp, void* handle, int max, std::list<std::string>& keys, bool* truncated) override;
virtual void meta_list_keys_complete(void* handle) override;
virtual std::string meta_get_marker(void *handle) override;
virtual int meta_remove(const DoutPrefixProvider *dpp, std::string& metadata_key, optional_yield y) override;
virtual const RGWSyncModuleInstanceRef& get_sync_module() { return sync_module; }
virtual std::string get_host_id() { return ""; }
virtual std::unique_ptr<LuaManager> get_lua_manager() override;
virtual std::unique_ptr<RGWRole> get_role(std::string name,
std::string tenant,
std::string path="",
std::string trust_policy="",
std::string max_session_duration_str="",
std::multimap<std::string, std::string> tags={}) override;
virtual std::unique_ptr<RGWRole> get_role(const RGWRoleInfo& info) override;
virtual std::unique_ptr<RGWRole> get_role(std::string id) override;
virtual int get_roles(const DoutPrefixProvider *dpp,
optional_yield y,
const std::string& path_prefix,
const std::string& tenant,
std::vector<std::unique_ptr<RGWRole>>& roles) override;
virtual std::unique_ptr<RGWOIDCProvider> get_oidc_provider() override;
virtual int get_oidc_providers(const DoutPrefixProvider *dpp,
const std::string& tenant,
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,
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,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag) override;
virtual const std::string& get_compression_type(const rgw_placement_rule& rule) override;
virtual bool valid_placement(const rgw_placement_rule& rule) override;
virtual void finalize(void) override;
virtual CephContext *ctx(void) override {
return cctx;
}
virtual void register_admin_apis(RGWRESTMgr* mgr) override { };
int open_idx(struct m0_uint128 *id, bool create, struct m0_idx *out);
void close_idx(struct m0_idx *idx) { m0_idx_fini(idx); }
int do_idx_op(struct m0_idx *, enum m0_idx_opcode opcode,
std::vector<uint8_t>& key, std::vector<uint8_t>& val, bool update = false);
int do_idx_next_op(struct m0_idx *idx,
std::vector<std::vector<uint8_t>>& key_vec,
std::vector<std::vector<uint8_t>>& val_vec);
int next_query_by_name(std::string idx_name, std::vector<std::string>& key_str_vec,
std::vector<bufferlist>& val_bl_vec,
std::string prefix="", std::string delim="");
void index_name_to_motr_fid(std::string iname, struct m0_uint128 *fid);
int open_motr_idx(struct m0_uint128 *id, struct m0_idx *idx);
int create_motr_idx_by_name(std::string iname);
int delete_motr_idx_by_name(std::string iname);
int do_idx_op_by_name(std::string idx_name, enum m0_idx_opcode opcode,
std::string key_str, bufferlist &bl, bool update=true);
int check_n_create_global_indices();
int store_access_key(const DoutPrefixProvider *dpp, optional_yield y, MotrAccessKey access_key);
int delete_access_key(const DoutPrefixProvider *dpp, optional_yield y, std::string access_key);
int store_email_info(const DoutPrefixProvider *dpp, optional_yield y, MotrEmailInfo& email_info);
int init_metadata_cache(const DoutPrefixProvider *dpp, CephContext *cct);
MotrMetaCache* get_obj_meta_cache() {return obj_meta_cache;}
MotrMetaCache* get_user_cache() {return user_cache;}
MotrMetaCache* get_bucket_inst_cache() {return bucket_inst_cache;}
};
struct obj_time_weight {
real_time mtime;
uint32_t zone_short_id;
uint64_t pg_ver;
bool high_precision;
obj_time_weight() : zone_short_id(0), pg_ver(0), high_precision(false) {}
bool compare_low_precision(const obj_time_weight& rhs) {
struct timespec l = ceph::real_clock::to_timespec(mtime);
struct timespec r = ceph::real_clock::to_timespec(rhs.mtime);
l.tv_nsec = 0;
r.tv_nsec = 0;
if (l > r) {
return false;
}
if (l < r) {
return true;
}
if (!zone_short_id || !rhs.zone_short_id) {
/* don't compare zone ids, if one wasn't provided */
return false;
}
if (zone_short_id != rhs.zone_short_id) {
return (zone_short_id < rhs.zone_short_id);
}
return (pg_ver < rhs.pg_ver);
}
bool operator<(const obj_time_weight& rhs) {
if (!high_precision || !rhs.high_precision) {
return compare_low_precision(rhs);
}
if (mtime > rhs.mtime) {
return false;
}
if (mtime < rhs.mtime) {
return true;
}
if (!zone_short_id || !rhs.zone_short_id) {
/* don't compare zone ids, if one wasn't provided */
return false;
}
if (zone_short_id != rhs.zone_short_id) {
return (zone_short_id < rhs.zone_short_id);
}
return (pg_ver < rhs.pg_ver);
}
void init(const real_time& _mtime, uint32_t _short_id, uint64_t _pg_ver) {
mtime = _mtime;
zone_short_id = _short_id;
pg_ver = _pg_ver;
}
void init(RGWObjState *state) {
mtime = state->mtime;
zone_short_id = state->zone_short_id;
pg_ver = state->pg_ver;
}
};
inline std::ostream& operator<<(std::ostream& out, const obj_time_weight &o) {
out << o.mtime;
if (o.zone_short_id != 0 || o.pg_ver != 0) {
out << "[zid=" << o.zone_short_id << ", pgv=" << o.pg_ver << "]";
}
return out;
}
} // namespace rgw::sal
| 51,012 | 41.724456 | 210 |
h
|
null |
ceph-main/src/rgw/rgw_sal_store.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2022 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#pragma once
#include "rgw_sal.h"
namespace rgw { namespace sal {
class StoreDriver : public Driver {
public:
StoreDriver() {}
virtual ~StoreDriver() = default;
virtual uint64_t get_new_req_id() override {
return ceph::util::generate_random_number<uint64_t>();
}
int read_topics(const std::string& tenant, rgw_pubsub_topics& topics, RGWObjVersionTracker* objv_tracker,
optional_yield y, const DoutPrefixProvider *dpp) override {return -EOPNOTSUPP;}
int write_topics(const std::string& tenant, const rgw_pubsub_topics& topics, RGWObjVersionTracker* objv_tracker,
optional_yield y, const DoutPrefixProvider *dpp) override {return -ENOENT;}
int remove_topics(const std::string& tenant, RGWObjVersionTracker* objv_tracker,
optional_yield y, const DoutPrefixProvider *dpp) override {return -ENOENT;}
};
class StoreUser : public User {
protected:
RGWUserInfo info;
RGWObjVersionTracker objv_tracker;
Attrs attrs;
public:
StoreUser() : info() {}
StoreUser(const rgw_user& _u) : info() { info.user_id = _u; }
StoreUser(const RGWUserInfo& _i) : info(_i) {}
StoreUser(StoreUser& _o) = default;
virtual ~StoreUser() = default;
virtual std::string& get_display_name() override { return info.display_name; }
virtual const std::string& get_tenant() override { return info.user_id.tenant; }
virtual void set_tenant(std::string& _t) override { info.user_id.tenant = _t; }
virtual const std::string& get_ns() override { return info.user_id.ns; }
virtual void set_ns(std::string& _ns) override { info.user_id.ns = _ns; }
virtual void clear_ns() override { info.user_id.ns.clear(); }
virtual const rgw_user& get_id() const override { return info.user_id; }
virtual uint32_t get_type() const override { return info.type; }
virtual int32_t get_max_buckets() const override { return info.max_buckets; }
virtual void set_max_buckets(int32_t _max_buckets) override {
info.max_buckets = _max_buckets;
}
virtual const RGWUserCaps& get_caps() const override { return info.caps; }
virtual RGWObjVersionTracker& get_version_tracker() override { return objv_tracker; }
virtual Attrs& get_attrs() override { return attrs; }
virtual void set_attrs(Attrs& _attrs) override { attrs = _attrs; }
virtual bool empty() const override { return info.user_id.id.empty(); }
virtual RGWUserInfo& get_info() override { return info; }
virtual void set_info(RGWQuotaInfo& _quota) override {
info.quota.user_quota.max_size = _quota.max_size;
info.quota.user_quota.max_objects = _quota.max_objects;
}
virtual void print(std::ostream& out) const override { out << info.user_id; }
friend class StoreBucket;
};
class StoreBucket : public Bucket {
protected:
RGWBucketEnt ent;
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) { ent.bucket = _b; info.bucket = _b; }
StoreBucket(const RGWBucketEnt& _e) : ent(_e) {
info.bucket = ent.bucket;
info.placement_rule = ent.placement_rule;
info.creation_time = ent.creation_time;
}
StoreBucket(const RGWBucketInfo& _i) : info(_i) {
ent.bucket = info.bucket;
ent.placement_rule = info.placement_rule;
ent.creation_time = info.creation_time;
}
StoreBucket(const rgw_bucket& _b, User* _u) :
owner(_u) { ent.bucket = _b; info.bucket = _b; }
StoreBucket(const RGWBucketEnt& _e, User* _u) : ent(_e), owner(_u) {
info.bucket = ent.bucket;
info.placement_rule = ent.placement_rule;
info.creation_time = ent.creation_time;
}
StoreBucket(const RGWBucketInfo& _i, User* _u) : info(_i), owner(_u) {
ent.bucket = info.bucket;
ent.placement_rule = info.placement_rule;
ent.creation_time = info.creation_time;
}
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;
}
virtual void set_count(uint64_t _count) override {
ent.count = _count;
}
virtual void set_size(uint64_t _size) override {
ent.size = _size;
}
virtual User* get_owner(void) override { return owner; };
virtual ACLOwner get_acl_owner(void) override { return ACLOwner(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; }
virtual const std::string& get_marker() const override { return info.bucket.marker; }
virtual const std::string& get_bucket_id() const override { return info.bucket.bucket_id; }
virtual size_t get_size() const override { return ent.size; }
virtual size_t get_size_rounded() const override { return ent.size_rounded; }
virtual uint64_t get_count() const override { return ent.count; }
virtual rgw_placement_rule& get_placement_rule() override { return info.placement_rule; }
virtual ceph::real_time& get_creation_time() override { return info.creation_time; }
virtual ceph::real_time& get_modification_time() override { return mtime; }
virtual obj_version& get_version() override { return bucket_version; }
virtual void set_version(obj_version &ver) override { bucket_version = ver; }
virtual bool versioned() override { return info.versioned(); }
virtual bool versioning_enabled() override { return info.versioning_enabled(); }
virtual rgw_bucket& get_key() override { return info.bucket; }
virtual RGWBucketInfo& get_info() override { return info; }
virtual void print(std::ostream& out) const override { out << info.bucket; }
virtual bool operator==(const Bucket& b) const override {
if (typeid(*this) != typeid(b)) {
return false;
}
const StoreBucket& sb = dynamic_cast<const StoreBucket&>(b);
return (info.bucket.tenant == sb.info.bucket.tenant) &&
(info.bucket.name == sb.info.bucket.name) &&
(info.bucket.bucket_id == sb.info.bucket.bucket_id);
}
virtual bool operator!=(const Bucket& b) const override {
if (typeid(*this) != typeid(b)) {
return false;
}
const StoreBucket& sb = dynamic_cast<const StoreBucket&>(b);
return (info.bucket.tenant != sb.info.bucket.tenant) ||
(info.bucket.name != sb.info.bucket.name) ||
(info.bucket.bucket_id != sb.info.bucket.bucket_id);
}
int read_topics(rgw_pubsub_bucket_topics& notifications, RGWObjVersionTracker* objv_tracker,
optional_yield y, const DoutPrefixProvider *dpp) override {return 0;}
int write_topics(const rgw_pubsub_bucket_topics& notifications, RGWObjVersionTracker* objv_tracker,
optional_yield y, const DoutPrefixProvider *dpp) override {return 0;}
int remove_topics(RGWObjVersionTracker* objv_tracker,
optional_yield y, const DoutPrefixProvider *dpp) override {return 0;}
friend class BucketList;
protected:
virtual void set_ent(RGWBucketEnt& _ent) { ent = _ent; info.bucket = ent.bucket; info.placement_rule = ent.placement_rule; }
};
class StoreObject : public Object {
protected:
RGWObjState state;
Bucket* bucket = nullptr;
bool delete_marker{false};
public:
StoreObject() = default;
StoreObject(const rgw_obj_key& _k)
{ state.obj.key = _k; }
StoreObject(const rgw_obj_key& _k, Bucket* _b)
: bucket(_b)
{ state.obj.init(_b->get_key(), _k); }
StoreObject(const StoreObject& _o) = default;
virtual ~StoreObject() = default;
virtual void set_atomic() override { state.is_atomic = true; }
virtual bool is_atomic() override { return state.is_atomic; }
virtual void set_prefetch_data() override { state.prefetch_data = true; }
virtual bool is_prefetch_data() override { return state.prefetch_data; }
virtual void set_compressed() override { state.compressed = true; }
virtual bool is_compressed() override { return state.compressed; }
virtual void invalidate() override {
rgw_obj obj = state.obj;
bool is_atomic = state.is_atomic;
bool prefetch_data = state.prefetch_data;
bool compressed = state.compressed;
state = RGWObjState();
state.obj = obj;
state.is_atomic = is_atomic;
state.prefetch_data = prefetch_data;
state.compressed = compressed;
}
virtual bool empty() const override { return state.obj.empty(); }
virtual const std::string &get_name() const override { return state.obj.key.name; }
virtual void set_obj_state(RGWObjState& _state) override {
state = _state;
}
virtual Attrs& get_attrs(void) override { return state.attrset; }
virtual const Attrs& get_attrs(void) const override { return state.attrset; }
virtual int set_attrs(Attrs a) override { state.attrset = a; state.has_attrs = true; return 0; }
virtual bool has_attrs(void) override { return state.has_attrs; }
virtual ceph::real_time get_mtime(void) const override { return state.mtime; }
virtual uint64_t get_obj_size(void) const override { return state.size; }
virtual Bucket* get_bucket(void) const override { return bucket; }
virtual void set_bucket(Bucket* b) override { bucket = b; state.obj.bucket = b->get_key(); }
virtual std::string get_hash_source(void) override { return state.obj.index_hash_source; }
virtual void set_hash_source(std::string s) override { state.obj.index_hash_source = s; }
virtual std::string get_oid(void) const override { return state.obj.key.get_oid(); }
virtual bool get_delete_marker(void) override { return delete_marker; }
virtual bool get_in_extra_data(void) override { return state.obj.is_in_extra_data(); }
virtual void set_in_extra_data(bool i) override { state.obj.set_in_extra_data(i); }
int range_to_ofs(uint64_t obj_size, int64_t &ofs, int64_t &end);
virtual void set_obj_size(uint64_t s) override { state.size = s; }
virtual void set_name(const std::string& n) override { state.obj.key = n; }
virtual void set_key(const rgw_obj_key& k) override { state.obj.key = k; }
virtual rgw_obj get_obj(void) const override { return state.obj; }
virtual rgw_obj_key& get_key() override { return state.obj.key; }
virtual void set_instance(const std::string &i) override { state.obj.key.set_instance(i); }
virtual const std::string &get_instance() const override { return state.obj.key.instance; }
virtual bool have_instance(void) override { return state.obj.key.have_instance(); }
virtual void clear_instance() override { state.obj.key.instance.clear(); }
virtual int transition_to_cloud(Bucket* bucket,
rgw::sal::PlacementTier* tier,
rgw_bucket_dir_entry& o,
std::set<std::string>& cloud_targets,
CephContext* cct,
bool update_object,
const DoutPrefixProvider* dpp,
optional_yield y) override {
/* Return failure here, so stores which don't transition to cloud will
* work with lifecycle */
return -1;
}
virtual int get_torrent_info(const DoutPrefixProvider* dpp,
optional_yield y, bufferlist& bl) override {
const auto& attrs = get_attrs();
if (auto i = attrs.find(RGW_ATTR_TORRENT); i != attrs.end()) {
bl = i->second;
return 0;
}
return -ENOENT;
}
virtual void print(std::ostream& out) const override {
if (bucket)
out << bucket << ":";
out << state.obj.key;
}
};
class StoreMultipartPart : public MultipartPart {
protected:
std::string oid;
public:
StoreMultipartPart() = default;
virtual ~StoreMultipartPart() = default;
};
class StoreMultipartUpload : public MultipartUpload {
protected:
Bucket* bucket;
std::map<uint32_t, std::unique_ptr<MultipartPart>> parts;
jspan_context trace_ctx{false, false};
public:
StoreMultipartUpload(Bucket* _bucket) : bucket(_bucket) {}
virtual ~StoreMultipartUpload() = default;
virtual std::map<uint32_t, std::unique_ptr<MultipartPart>>& get_parts() override { return parts; }
virtual const jspan_context& get_trace() override { return trace_ctx; }
virtual void print(std::ostream& out) const override {
out << get_meta();
if (!get_upload_id().empty())
out << ":" << get_upload_id();
}
};
class StoreMPSerializer : public MPSerializer {
protected:
bool locked;
std::string oid;
public:
StoreMPSerializer() : locked(false) {}
StoreMPSerializer(std::string _oid) : locked(false), oid(_oid) {}
virtual ~StoreMPSerializer() = default;
virtual void clear_locked() override {
locked = false;
}
virtual bool is_locked() override { return locked; }
virtual void print(std::ostream& out) const override { out << oid; }
};
class StoreLCSerializer : public LCSerializer {
protected:
std::string oid;
public:
StoreLCSerializer() {}
StoreLCSerializer(std::string _oid) : oid(_oid) {}
virtual ~StoreLCSerializer() = default;
virtual void print(std::ostream& out) const override { out << oid; }
};
class StoreLifecycle : public Lifecycle {
public:
struct StoreLCHead : LCHead {
time_t start_date{0};
time_t shard_rollover_date{0};
std::string marker;
StoreLCHead() = default;
StoreLCHead(time_t _start_date, time_t _rollover_date, std::string& _marker) : start_date(_start_date), shard_rollover_date(_rollover_date), marker(_marker) {}
StoreLCHead& operator=(LCHead& _h) {
start_date = _h.get_start_date();
shard_rollover_date = _h.get_shard_rollover_date();
marker = _h.get_marker();
return *this;
}
virtual time_t& get_start_date() override { return start_date; }
virtual void set_start_date(time_t _date) override { start_date = _date; }
virtual std::string& get_marker() override { return marker; }
virtual void set_marker(const std::string& _marker) override { marker = _marker; }
virtual time_t& get_shard_rollover_date() override { return shard_rollover_date; }
virtual void set_shard_rollover_date(time_t _date) override { shard_rollover_date = _date; }
};
struct StoreLCEntry : LCEntry {
std::string bucket;
std::string oid;
uint64_t start_time{0};
uint32_t status{0};
StoreLCEntry() = default;
StoreLCEntry(std::string& _bucket, uint64_t _time, uint32_t _status) : bucket(_bucket), start_time(_time), status(_status) {}
StoreLCEntry(std::string& _bucket, std::string _oid, uint64_t _time, uint32_t _status) : bucket(_bucket), oid(_oid), start_time(_time), status(_status) {}
StoreLCEntry(const StoreLCEntry& _e) = default;
StoreLCEntry& operator=(LCEntry& _e) {
bucket = _e.get_bucket();
oid = _e.get_oid();
start_time = _e.get_start_time();
status = _e.get_status();
return *this;
}
virtual std::string& get_bucket() override { return bucket; }
virtual void set_bucket(const std::string& _bucket) override { bucket = _bucket; }
virtual std::string& get_oid() override { return oid; }
virtual void set_oid(const std::string& _oid) override { oid = _oid; }
virtual uint64_t get_start_time() override { return start_time; }
virtual void set_start_time(uint64_t _time) override { start_time = _time; }
virtual uint32_t get_status() override { return status; }
virtual void set_status(uint32_t _status) override { status = _status; }
virtual void print(std::ostream& out) const override {
out << bucket << ":" << oid << ":" << start_time << ":" << status;
}
};
StoreLifecycle() = default;
virtual ~StoreLifecycle() = default;
virtual std::unique_ptr<LCEntry> get_entry() override {
return std::make_unique<StoreLCEntry>();
}
using Lifecycle::get_entry;
};
class StoreNotification : public Notification {
protected:
Object* obj;
Object* src_obj;
rgw::notify::EventType event_type;
public:
StoreNotification(Object* _obj, Object* _src_obj, rgw::notify::EventType _type)
: obj(_obj), src_obj(_src_obj), event_type(_type)
{}
virtual ~StoreNotification() = default;
};
class StoreWriter : public Writer {
protected:
const DoutPrefixProvider* dpp;
public:
StoreWriter(const DoutPrefixProvider *_dpp, optional_yield y) : dpp(_dpp) {}
virtual ~StoreWriter() = default;
};
class StorePlacementTier : public PlacementTier {
public:
virtual ~StorePlacementTier() = default;
};
class StoreZoneGroup : public ZoneGroup {
public:
virtual ~StoreZoneGroup() = default;
};
class StoreZone : public Zone {
public:
virtual ~StoreZone() = default;
};
class StoreLuaManager : public LuaManager {
public:
virtual ~StoreLuaManager() = default;
};
} } // namespace rgw::sal
| 17,406 | 37.941834 | 163 |
h
|
null |
ceph-main/src/rgw/rgw_signal.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2022 Red Hat, Inc
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "rgw_signal.h"
#include "global/signal_handler.h"
#include "common/safe_io.h"
#include "common/errno.h"
#include "rgw_main.h"
#include "rgw_log.h"
#ifdef HAVE_SYS_PRCTL_H
#include <sys/prctl.h>
#endif
#define dout_subsys ceph_subsys_rgw
#define dout_context g_ceph_context
static int signal_fd[2] = {0, 0};
namespace rgw {
namespace signal {
void sighup_handler(int signum) {
if (rgw::AppMain::ops_log_file != nullptr) {
rgw::AppMain::ops_log_file->reopen();
}
g_ceph_context->reopen_logs();
} /* sighup_handler */
void signal_shutdown()
{
int val = 0;
int ret = write(signal_fd[0], (char *)&val, sizeof(val));
if (ret < 0) {
derr << "ERROR: " << __func__ << ": write() returned "
<< cpp_strerror(errno) << dendl;
}
} /* signal_shutdown */
void wait_shutdown()
{
int val;
int r = safe_read_exact(signal_fd[1], &val, sizeof(val));
if (r < 0) {
derr << "safe_read_exact returned with error" << dendl;
}
} /* wait_shutdown */
int signal_fd_init()
{
return socketpair(AF_UNIX, SOCK_STREAM, 0, signal_fd);
} /* signal_fd_init */
void signal_fd_finalize()
{
close(signal_fd[0]);
close(signal_fd[1]);
} /* signal_fd_finalize */
void handle_sigterm(int signum)
{
dout(1) << __func__ << dendl;
// send a signal to make fcgi's accept(2) wake up. unfortunately the
// initial signal often isn't sufficient because we race with accept's
// check of the flag wet by ShutdownPending() above.
if (signum != SIGUSR1) {
signal_shutdown();
// safety net in case we get stuck doing an orderly shutdown.
uint64_t secs = g_ceph_context->_conf->rgw_exit_timeout_secs;
if (secs)
alarm(secs);
dout(1) << __func__ << " set alarm for " << secs << dendl;
}
} /* handle_sigterm */
}} /* namespace rgw::signal */
| 2,217 | 23.108696 | 72 |
cc
|
null |
ceph-main/src/rgw/rgw_signal.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2022 Red Hat, Inc
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#pragma once
namespace rgw {
namespace signal {
void signal_shutdown();
void wait_shutdown();
int signal_fd_init();
void signal_fd_finalize();
void handle_sigterm(int signum);
void handle_sigterm(int signum);
void sighup_handler(int signum);
} // namespace signal
} // namespace rgw
| 699 | 20.875 | 70 |
h
|
null |
ceph-main/src/rgw/rgw_string.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#include "rgw_string.h"
static bool char_eq(char c1, char c2)
{
return c1 == c2;
}
static bool ci_char_eq(char c1, char c2)
{
return tolower(c1) == tolower(c2);
}
bool match_wildcards(std::string_view pattern, std::string_view input,
uint32_t flags)
{
const auto eq = (flags & MATCH_CASE_INSENSITIVE) ? &ci_char_eq : &char_eq;
auto it1 = pattern.begin();
auto it2 = input.begin();
while (true) {
if (it1 == pattern.end())
return it2 == input.end();
if (*it1 == '*') {
if (it1 + 1 == pattern.end())
return true;
if (it2 == input.end() || eq(*(it1 + 1), *it2))
++it1;
else
++it2;
continue;
}
if (it2 == input.end())
return false;
if (*it1 == '?' || eq(*it1, *it2)) {
++it1;
++it2;
continue;
}
return false;
}
return false;
}
| 976 | 20.23913 | 76 |
cc
|
null |
ceph-main/src/rgw/rgw_string.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#pragma once
#include <errno.h>
#include <stdlib.h>
#include <limits.h>
#include <string_view>
#include <string>
#include <stdexcept>
#include <boost/container/small_vector.hpp>
struct ltstr_nocase
{
bool operator()(const std::string& s1, const std::string& s2) const
{
return strcasecmp(s1.c_str(), s2.c_str()) < 0;
}
};
static inline int stringcasecmp(const std::string& s1, const std::string& s2)
{
return strcasecmp(s1.c_str(), s2.c_str());
}
static inline int stringcasecmp(const std::string& s1, const char *s2)
{
return strcasecmp(s1.c_str(), s2);
}
static inline int stringcasecmp(const std::string& s1, int ofs, int size, const std::string& s2)
{
return strncasecmp(s1.c_str() + ofs, s2.c_str(), size);
}
static inline int stringtoll(const std::string& s, int64_t *val)
{
char *end;
long long result = strtoll(s.c_str(), &end, 10);
if (result == LLONG_MAX)
return -EINVAL;
if (*end)
return -EINVAL;
*val = (int64_t)result;
return 0;
}
static inline int stringtoull(const std::string& s, uint64_t *val)
{
char *end;
unsigned long long result = strtoull(s.c_str(), &end, 10);
if (result == ULLONG_MAX)
return -EINVAL;
if (*end)
return -EINVAL;
*val = (uint64_t)result;
return 0;
}
static inline int stringtol(const std::string& s, int32_t *val)
{
char *end;
long result = strtol(s.c_str(), &end, 10);
if (result == LONG_MAX)
return -EINVAL;
if (*end)
return -EINVAL;
*val = (int32_t)result;
return 0;
}
static inline int stringtoul(const std::string& s, uint32_t *val)
{
char *end;
unsigned long result = strtoul(s.c_str(), &end, 10);
if (result == ULONG_MAX)
return -EINVAL;
if (*end)
return -EINVAL;
*val = (uint32_t)result;
return 0;
}
/* A converter between std::string_view and null-terminated C-strings.
* It copies memory while trying to utilize the local memory instead of
* issuing dynamic allocations. */
template<std::size_t N = 128>
static inline boost::container::small_vector<char, N>
sview2cstr(const std::string_view& sv)
{
boost::container::small_vector<char, N> cstr;
cstr.reserve(sv.size() + sizeof('\0'));
cstr.assign(std::begin(sv), std::end(sv));
cstr.push_back('\0');
return cstr;
}
/* std::strlen() isn't guaranteed to be computable at compile-time. Although
* newer GCCs actually do that, Clang doesn't. Please be aware this function
* IS NOT A DROP-IN REPLACEMENT FOR STRLEN -- it returns a different result
* for strings having \0 in the middle. */
template<size_t N>
static inline constexpr size_t sarrlen(const char (&arr)[N]) {
return N - 1;
}
namespace detail {
// variadic sum() to add up string lengths for reserve()
static inline constexpr size_t sum() { return 0; }
template <typename... Args>
constexpr size_t sum(size_t v, Args... args) { return v + sum(args...); }
// traits for string_size()
template <typename T>
struct string_traits {
static constexpr size_t size(const T& s) { return s.size(); }
};
// specializations for char*/const char* use strlen()
template <>
struct string_traits<const char*> {
static size_t size(const char* s) { return std::strlen(s); }
};
template <>
struct string_traits<char*> : string_traits<const char*> {};
// constexpr specializations for char[]/const char[]
template <std::size_t N>
struct string_traits<const char[N]> {
static constexpr size_t size_(const char* s, size_t i) {
return i < N ? (*(s + i) == '\0' ? i : size_(s, i + 1))
: throw std::invalid_argument("Unterminated string constant.");
}
static constexpr size_t size(const char(&s)[N]) { return size_(s, 0); }
};
template <std::size_t N>
struct string_traits<char[N]> : string_traits<const char[N]> {};
// helpers for string_cat_reserve()
static inline void append_to(std::string& s) {}
template <typename... Args>
void append_to(std::string& s, const std::string_view& v, const Args&... args)
{
s.append(v.begin(), v.end());
append_to(s, args...);
}
// helpers for string_join_reserve()
static inline void join_next(std::string& s, const std::string_view& d) {}
template <typename... Args>
void join_next(std::string& s, const std::string_view& d,
const std::string_view& v, const Args&... args)
{
s.append(d.begin(), d.end());
s.append(v.begin(), v.end());
join_next(s, d, args...);
}
static inline void join(std::string& s, const std::string_view& d) {}
template <typename... Args>
void join(std::string& s, const std::string_view& d,
const std::string_view& v, const Args&... args)
{
s.append(v.begin(), v.end());
join_next(s, d, args...);
}
} // namespace detail
/// return the length of a c string, string literal, or string type
template <typename T>
constexpr size_t string_size(const T& s)
{
return detail::string_traits<T>::size(s);
}
/// concatenates the given string arguments, returning as a std::string that
/// gets preallocated with reserve()
template <typename... Args>
std::string string_cat_reserve(const Args&... args)
{
size_t total_size = detail::sum(string_size(args)...);
std::string result;
result.reserve(total_size);
detail::append_to(result, args...);
return result;
}
/// joins the given string arguments with a delimiter, returning as a
/// std::string that gets preallocated with reserve()
template <typename... Args>
std::string string_join_reserve(const std::string_view& delim,
const Args&... args)
{
size_t delim_size = delim.size() * std::max<ssize_t>(0, sizeof...(args) - 1);
size_t total_size = detail::sum(string_size(args)...) + delim_size;
std::string result;
result.reserve(total_size);
detail::join(result, delim, args...);
return result;
}
template <typename... Args>
std::string string_join_reserve(char delim, const Args&... args)
{
return string_join_reserve(std::string_view{&delim, 1}, args...);
}
/// use case-insensitive comparison in match_wildcards()
static constexpr uint32_t MATCH_CASE_INSENSITIVE = 0x01;
/// attempt to match the given input string with the pattern, which may contain
/// the wildcard characters * and ?
extern bool match_wildcards(std::string_view pattern,
std::string_view input,
uint32_t flags = 0);
| 6,357 | 25.940678 | 96 |
h
|
null |
ceph-main/src/rgw/rgw_sts.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#include <errno.h>
#include <ctime>
#include <regex>
#include <boost/format.hpp>
#include <boost/algorithm/string/replace.hpp>
#include "common/errno.h"
#include "common/Formatter.h"
#include "common/ceph_json.h"
#include "common/ceph_time.h"
#include "auth/Crypto.h"
#include "include/ceph_fs.h"
#include "common/iso_8601.h"
#include "include/types.h"
#include "rgw_string.h"
#include "rgw_b64.h"
#include "rgw_common.h"
#include "rgw_tools.h"
#include "rgw_role.h"
#include "rgw_user.h"
#include "rgw_iam_policy.h"
#include "rgw_sts.h"
#include "rgw_sal.h"
#include "rgw_sal_rados.h"
#define dout_subsys ceph_subsys_rgw
using namespace std;
namespace STS {
void Credentials::dump(Formatter *f) const
{
encode_json("AccessKeyId", accessKeyId , f);
encode_json("Expiration", expiration , f);
encode_json("SecretAccessKey", secretAccessKey , f);
encode_json("SessionToken", sessionToken , f);
}
int Credentials::generateCredentials(const DoutPrefixProvider *dpp,
CephContext* cct,
const uint64_t& duration,
const boost::optional<std::string>& policy,
const boost::optional<std::string>& roleId,
const boost::optional<std::string>& role_session,
const boost::optional<std::vector<std::string>>& token_claims,
const boost::optional<std::vector<std::pair<std::string,std::string>>>& session_princ_tags,
boost::optional<rgw_user> user,
rgw::auth::Identity* identity)
{
uuid_d accessKey, secretKey;
char accessKeyId_str[MAX_ACCESS_KEY_LEN], secretAccessKey_str[MAX_SECRET_KEY_LEN];
//AccessKeyId
gen_rand_alphanumeric_plain(cct, accessKeyId_str, sizeof(accessKeyId_str));
accessKeyId = accessKeyId_str;
//SecretAccessKey
gen_rand_alphanumeric_upper(cct, secretAccessKey_str, sizeof(secretAccessKey_str));
secretAccessKey = secretAccessKey_str;
//Expiration
real_clock::time_point t = real_clock::now();
real_clock::time_point exp = t + std::chrono::seconds(duration);
expiration = ceph::to_iso_8601(exp);
//Session Token - Encrypt using AES
auto* cryptohandler = cct->get_crypto_handler(CEPH_CRYPTO_AES);
if (! cryptohandler) {
ldpp_dout(dpp, 0) << "ERROR: No AES cryto handler found !" << dendl;
return -EINVAL;
}
string secret_s = cct->_conf->rgw_sts_key;
buffer::ptr secret(secret_s.c_str(), secret_s.length());
int ret = 0;
if (ret = cryptohandler->validate_secret(secret); ret < 0) {
ldpp_dout(dpp, 0) << "ERROR: Invalid rgw sts key, please ensure its length is 16" << dendl;
return ret;
}
string error;
std::unique_ptr<CryptoKeyHandler> keyhandler(cryptohandler->get_key_handler(secret, error));
if (! keyhandler) {
ldpp_dout(dpp, 0) << "ERROR: No Key handler found !" << dendl;
return -EINVAL;
}
error.clear();
//Storing policy and roleId as part of token, so that they can be extracted
// from the token itself for policy evaluation.
SessionToken token;
//authentication info
token.access_key_id = accessKeyId;
token.secret_access_key = secretAccessKey;
token.expiration = expiration;
token.issued_at = ceph::to_iso_8601(t);
//Authorization info
if (policy)
token.policy = *policy;
else
token.policy = {};
if (roleId)
token.roleId = *roleId;
else
token.roleId = {};
if (user)
token.user = *user;
else {
rgw_user u({}, {}, {});
token.user = u;
}
if (token_claims) {
token.token_claims = std::move(*token_claims);
}
if (identity) {
token.acct_name = identity->get_acct_name();
token.perm_mask = identity->get_perm_mask();
token.is_admin = identity->is_admin_of(token.user);
token.acct_type = identity->get_identity_type();
} else {
token.acct_name = {};
token.perm_mask = 0;
token.is_admin = 0;
token.acct_type = TYPE_ROLE;
token.role_session = role_session.get();
}
if (session_princ_tags) {
token.principal_tags = std::move(*session_princ_tags);
}
buffer::list input, enc_output;
encode(token, input);
if (ret = keyhandler->encrypt(input, enc_output, &error); ret < 0) {
ldpp_dout(dpp, 0) << "ERROR: Encrypting session token returned an error !" << dendl;
return ret;
}
bufferlist encoded_op;
enc_output.encode_base64(encoded_op);
encoded_op.append('\0');
sessionToken = encoded_op.c_str();
return ret;
}
void AssumedRoleUser::dump(Formatter *f) const
{
encode_json("Arn", arn , f);
encode_json("AssumeRoleId", assumeRoleId , f);
}
int AssumedRoleUser::generateAssumedRoleUser(CephContext* cct,
rgw::sal::Driver* driver,
const string& roleId,
const rgw::ARN& roleArn,
const string& roleSessionName)
{
string resource = std::move(roleArn.resource);
boost::replace_first(resource, "role", "assumed-role");
resource.append("/");
resource.append(roleSessionName);
rgw::ARN assumed_role_arn(rgw::Partition::aws,
rgw::Service::sts,
"", roleArn.account, resource);
arn = assumed_role_arn.to_string();
//Assumeroleid = roleid:rolesessionname
assumeRoleId = roleId + ":" + roleSessionName;
return 0;
}
AssumeRoleRequestBase::AssumeRoleRequestBase( CephContext* cct,
const string& duration,
const string& iamPolicy,
const string& roleArn,
const string& roleSessionName)
: cct(cct), iamPolicy(iamPolicy), roleArn(roleArn), roleSessionName(roleSessionName)
{
MIN_DURATION_IN_SECS = cct->_conf->rgw_sts_min_session_duration;
if (duration.empty()) {
this->duration = DEFAULT_DURATION_IN_SECS;
} else {
this->duration = strict_strtoll(duration.c_str(), 10, &this->err_msg);
}
}
int AssumeRoleRequestBase::validate_input(const DoutPrefixProvider *dpp) const
{
if (!err_msg.empty()) {
ldpp_dout(dpp, 0) << "ERROR: error message is empty !" << dendl;
return -EINVAL;
}
if (duration < MIN_DURATION_IN_SECS ||
duration > MAX_DURATION_IN_SECS) {
ldpp_dout(dpp, 0) << "ERROR: Incorrect value of duration: " << duration << dendl;
return -EINVAL;
}
if (! iamPolicy.empty() &&
(iamPolicy.size() < MIN_POLICY_SIZE || iamPolicy.size() > MAX_POLICY_SIZE)) {
ldpp_dout(dpp, 0) << "ERROR: Incorrect size of iamPolicy: " << iamPolicy.size() << dendl;
return -ERR_PACKED_POLICY_TOO_LARGE;
}
if (! roleArn.empty() &&
(roleArn.size() < MIN_ROLE_ARN_SIZE || roleArn.size() > MAX_ROLE_ARN_SIZE)) {
ldpp_dout(dpp, 0) << "ERROR: Incorrect size of roleArn: " << roleArn.size() << dendl;
return -EINVAL;
}
if (! roleSessionName.empty()) {
if (roleSessionName.size() < MIN_ROLE_SESSION_SIZE || roleSessionName.size() > MAX_ROLE_SESSION_SIZE) {
ldpp_dout(dpp, 0) << "ERROR: Either role session name is empty or role session size is incorrect: " << roleSessionName.size() << dendl;
return -EINVAL;
}
std::regex regex_roleSession("[A-Za-z0-9_=,.@-]+");
if (! std::regex_match(roleSessionName, regex_roleSession)) {
ldpp_dout(dpp, 0) << "ERROR: Role session name is incorrect: " << roleSessionName << dendl;
return -EINVAL;
}
}
return 0;
}
int AssumeRoleWithWebIdentityRequest::validate_input(const DoutPrefixProvider *dpp) const
{
if (! providerId.empty()) {
if (providerId.length() < MIN_PROVIDER_ID_LEN ||
providerId.length() > MAX_PROVIDER_ID_LEN) {
ldpp_dout(dpp, 0) << "ERROR: Either provider id is empty or provider id length is incorrect: " << providerId.length() << dendl;
return -EINVAL;
}
}
return AssumeRoleRequestBase::validate_input(dpp);
}
int AssumeRoleRequest::validate_input(const DoutPrefixProvider *dpp) const
{
if (! externalId.empty()) {
if (externalId.length() < MIN_EXTERNAL_ID_LEN ||
externalId.length() > MAX_EXTERNAL_ID_LEN) {
ldpp_dout(dpp, 0) << "ERROR: Either external id is empty or external id length is incorrect: " << externalId.length() << dendl;
return -EINVAL;
}
std::regex regex_externalId("[A-Za-z0-9_=,.@:/-]+");
if (! std::regex_match(externalId, regex_externalId)) {
ldpp_dout(dpp, 0) << "ERROR: Invalid external Id: " << externalId << dendl;
return -EINVAL;
}
}
if (! serialNumber.empty()){
if (serialNumber.size() < MIN_SERIAL_NUMBER_SIZE || serialNumber.size() > MAX_SERIAL_NUMBER_SIZE) {
ldpp_dout(dpp, 0) << "Either serial number is empty or serial number length is incorrect: " << serialNumber.size() << dendl;
return -EINVAL;
}
std::regex regex_serialNumber("[A-Za-z0-9_=/:,.@-]+");
if (! std::regex_match(serialNumber, regex_serialNumber)) {
ldpp_dout(dpp, 0) << "Incorrect serial number: " << serialNumber << dendl;
return -EINVAL;
}
}
if (! tokenCode.empty() && tokenCode.size() == TOKEN_CODE_SIZE) {
ldpp_dout(dpp, 0) << "Either token code is empty or token code size is invalid: " << tokenCode.size() << dendl;
return -EINVAL;
}
return AssumeRoleRequestBase::validate_input(dpp);
}
std::tuple<int, rgw::sal::RGWRole*> STSService::getRoleInfo(const DoutPrefixProvider *dpp,
const string& arn,
optional_yield y)
{
if (auto r_arn = rgw::ARN::parse(arn); r_arn) {
auto pos = r_arn->resource.find_last_of('/');
string roleName = r_arn->resource.substr(pos + 1);
std::unique_ptr<rgw::sal::RGWRole> role = driver->get_role(roleName, r_arn->account);
if (int ret = role->get(dpp, y); ret < 0) {
if (ret == -ENOENT) {
ldpp_dout(dpp, 0) << "Role doesn't exist: " << roleName << dendl;
ret = -ERR_NO_ROLE_FOUND;
}
return make_tuple(ret, nullptr);
} else {
auto path_pos = r_arn->resource.find('/');
string path;
if (path_pos == pos) {
path = "/";
} else {
path = r_arn->resource.substr(path_pos, ((pos - path_pos) + 1));
}
string r_path = role->get_path();
if (path != r_path) {
ldpp_dout(dpp, 0) << "Invalid Role ARN: Path in ARN does not match with the role path: " << path << " " << r_path << dendl;
return make_tuple(-EACCES, nullptr);
}
this->role = std::move(role);
return make_tuple(0, this->role.get());
}
} else {
ldpp_dout(dpp, 0) << "Invalid role arn: " << arn << dendl;
return make_tuple(-EINVAL, nullptr);
}
}
AssumeRoleWithWebIdentityResponse STSService::assumeRoleWithWebIdentity(const DoutPrefixProvider *dpp, AssumeRoleWithWebIdentityRequest& req)
{
AssumeRoleWithWebIdentityResponse response;
response.assumeRoleResp.packedPolicySize = 0;
std::vector<string> token_claims;
if (req.getProviderId().empty()) {
response.providerId = req.getIss();
}
response.aud = req.getAud();
response.sub = req.getSub();
token_claims.emplace_back(string("iss") + ":" + req.getIss());
token_claims.emplace_back(string("aud") + ":" + req.getAud());
token_claims.emplace_back(string("sub") + ":" + req.getSub());
//Get the role info which is being assumed
boost::optional<rgw::ARN> r_arn = rgw::ARN::parse(req.getRoleARN());
if (r_arn == boost::none) {
ldpp_dout(dpp, 0) << "Error in parsing role arn: " << req.getRoleARN() << dendl;
response.assumeRoleResp.retCode = -EINVAL;
return response;
}
string roleId = role->get_id();
uint64_t roleMaxSessionDuration = role->get_max_session_duration();
req.setMaxDuration(roleMaxSessionDuration);
//Validate input
response.assumeRoleResp.retCode = req.validate_input(dpp);
if (response.assumeRoleResp.retCode < 0) {
return response;
}
//Calculate PackedPolicySize
string policy = req.getPolicy();
response.assumeRoleResp.packedPolicySize = (policy.size() / req.getMaxPolicySize()) * 100;
//Generate Assumed Role User
response.assumeRoleResp.retCode = response.assumeRoleResp.user.generateAssumedRoleUser(cct,
driver,
roleId,
r_arn.get(),
req.getRoleSessionName());
if (response.assumeRoleResp.retCode < 0) {
return response;
}
//Generate Credentials
//Role and Policy provide the authorization info, user id and applier info are not needed
response.assumeRoleResp.retCode = response.assumeRoleResp.creds.generateCredentials(dpp, cct, req.getDuration(),
req.getPolicy(), roleId,
req.getRoleSessionName(),
token_claims,
req.getPrincipalTags(),
user_id, nullptr);
if (response.assumeRoleResp.retCode < 0) {
return response;
}
response.assumeRoleResp.retCode = 0;
return response;
}
AssumeRoleResponse STSService::assumeRole(const DoutPrefixProvider *dpp,
AssumeRoleRequest& req,
optional_yield y)
{
AssumeRoleResponse response;
response.packedPolicySize = 0;
//Get the role info which is being assumed
boost::optional<rgw::ARN> r_arn = rgw::ARN::parse(req.getRoleARN());
if (r_arn == boost::none) {
ldpp_dout(dpp, 0) << "Error in parsing role arn: " << req.getRoleARN() << dendl;
response.retCode = -EINVAL;
return response;
}
string roleId = role->get_id();
uint64_t roleMaxSessionDuration = role->get_max_session_duration();
req.setMaxDuration(roleMaxSessionDuration);
//Validate input
response.retCode = req.validate_input(dpp);
if (response.retCode < 0) {
return response;
}
//Calculate PackedPolicySize
string policy = req.getPolicy();
response.packedPolicySize = (policy.size() / req.getMaxPolicySize()) * 100;
//Generate Assumed Role User
response.retCode = response.user.generateAssumedRoleUser(cct, driver, roleId, r_arn.get(), req.getRoleSessionName());
if (response.retCode < 0) {
return response;
}
//Generate Credentials
//Role and Policy provide the authorization info, user id and applier info are not needed
response.retCode = response.creds.generateCredentials(dpp, cct, req.getDuration(),
req.getPolicy(), roleId,
req.getRoleSessionName(),
boost::none,
boost::none,
user_id, nullptr);
if (response.retCode < 0) {
return response;
}
response.retCode = 0;
return response;
}
GetSessionTokenRequest::GetSessionTokenRequest(const string& duration, const string& serialNumber, const string& tokenCode)
{
if (duration.empty()) {
this->duration = DEFAULT_DURATION_IN_SECS;
} else {
this->duration = stoull(duration);
}
this->serialNumber = serialNumber;
this->tokenCode = tokenCode;
}
GetSessionTokenResponse STSService::getSessionToken(const DoutPrefixProvider *dpp, GetSessionTokenRequest& req)
{
int ret;
Credentials cred;
//Generate Credentials
if (ret = cred.generateCredentials(dpp, cct,
req.getDuration(),
boost::none,
boost::none,
boost::none,
boost::none,
boost::none,
user_id,
identity); ret < 0) {
return make_tuple(ret, cred);
}
return make_tuple(0, cred);
}
}
| 16,619 | 34.361702 | 141 |
cc
|
null |
ceph-main/src/rgw/rgw_sts.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#pragma once
#include "rgw_role.h"
#include "rgw_auth.h"
#include "rgw_web_idp.h"
namespace STS {
class AssumeRoleRequestBase {
protected:
static constexpr uint64_t MIN_POLICY_SIZE = 1;
static constexpr uint64_t MAX_POLICY_SIZE = 2048;
static constexpr uint64_t DEFAULT_DURATION_IN_SECS = 3600;
static constexpr uint64_t MIN_ROLE_ARN_SIZE = 2;
static constexpr uint64_t MAX_ROLE_ARN_SIZE = 2048;
static constexpr uint64_t MIN_ROLE_SESSION_SIZE = 2;
static constexpr uint64_t MAX_ROLE_SESSION_SIZE = 64;
uint64_t MIN_DURATION_IN_SECS;
uint64_t MAX_DURATION_IN_SECS;
CephContext* cct;
uint64_t duration;
std::string err_msg;
std::string iamPolicy;
std::string roleArn;
std::string roleSessionName;
public:
AssumeRoleRequestBase(CephContext* cct,
const std::string& duration,
const std::string& iamPolicy,
const std::string& roleArn,
const std::string& roleSessionName);
const std::string& getRoleARN() const { return roleArn; }
const std::string& getRoleSessionName() const { return roleSessionName; }
const std::string& getPolicy() const {return iamPolicy; }
static const uint64_t& getMaxPolicySize() { return MAX_POLICY_SIZE; }
void setMaxDuration(const uint64_t& maxDuration) { MAX_DURATION_IN_SECS = maxDuration; }
const uint64_t& getDuration() const { return duration; }
int validate_input(const DoutPrefixProvider *dpp) const;
};
class AssumeRoleWithWebIdentityRequest : public AssumeRoleRequestBase {
static constexpr uint64_t MIN_PROVIDER_ID_LEN = 4;
static constexpr uint64_t MAX_PROVIDER_ID_LEN = 2048;
std::string providerId;
std::string iamPolicy;
std::string iss;
std::string sub;
std::string aud;
std::vector<std::pair<std::string,std::string>> session_princ_tags;
public:
AssumeRoleWithWebIdentityRequest( CephContext* cct,
const std::string& duration,
const std::string& providerId,
const std::string& iamPolicy,
const std::string& roleArn,
const std::string& roleSessionName,
const std::string& iss,
const std::string& sub,
const std::string& aud,
std::vector<std::pair<std::string,std::string>> session_princ_tags)
: AssumeRoleRequestBase(cct, duration, iamPolicy, roleArn, roleSessionName),
providerId(providerId), iss(iss), sub(sub), aud(aud), session_princ_tags(session_princ_tags) {}
const std::string& getProviderId() const { return providerId; }
const std::string& getIss() const { return iss; }
const std::string& getAud() const { return aud; }
const std::string& getSub() const { return sub; }
const std::vector<std::pair<std::string,std::string>>& getPrincipalTags() const { return session_princ_tags; }
int validate_input(const DoutPrefixProvider *dpp) const;
};
class AssumeRoleRequest : public AssumeRoleRequestBase {
static constexpr uint64_t MIN_EXTERNAL_ID_LEN = 2;
static constexpr uint64_t MAX_EXTERNAL_ID_LEN = 1224;
static constexpr uint64_t MIN_SERIAL_NUMBER_SIZE = 9;
static constexpr uint64_t MAX_SERIAL_NUMBER_SIZE = 256;
static constexpr uint64_t TOKEN_CODE_SIZE = 6;
std::string externalId;
std::string serialNumber;
std::string tokenCode;
public:
AssumeRoleRequest(CephContext* cct,
const std::string& duration,
const std::string& externalId,
const std::string& iamPolicy,
const std::string& roleArn,
const std::string& roleSessionName,
const std::string& serialNumber,
const std::string& tokenCode)
: AssumeRoleRequestBase(cct, duration, iamPolicy, roleArn, roleSessionName),
externalId(externalId), serialNumber(serialNumber), tokenCode(tokenCode){}
int validate_input(const DoutPrefixProvider *dpp) const;
};
class GetSessionTokenRequest {
protected:
static constexpr uint64_t MIN_DURATION_IN_SECS = 900;
static constexpr uint64_t DEFAULT_DURATION_IN_SECS = 3600;
uint64_t duration;
std::string serialNumber;
std::string tokenCode;
public:
GetSessionTokenRequest(const std::string& duration, const std::string& serialNumber, const std::string& tokenCode);
const uint64_t& getDuration() const { return duration; }
static const uint64_t& getMinDuration() { return MIN_DURATION_IN_SECS; }
};
class AssumedRoleUser {
std::string arn;
std::string assumeRoleId;
public:
int generateAssumedRoleUser( CephContext* cct,
rgw::sal::Driver* driver,
const std::string& roleId,
const rgw::ARN& roleArn,
const std::string& roleSessionName);
const std::string& getARN() const { return arn; }
const std::string& getAssumeRoleId() const { return assumeRoleId; }
void dump(Formatter *f) const;
};
struct SessionToken {
std::string access_key_id;
std::string secret_access_key;
std::string expiration;
std::string policy;
std::string roleId;
rgw_user user;
std::string acct_name;
uint32_t perm_mask;
bool is_admin;
uint32_t acct_type;
std::string role_session;
std::vector<std::string> token_claims;
std::string issued_at;
std::vector<std::pair<std::string,std::string>> principal_tags;
SessionToken() {}
void encode(bufferlist& bl) const {
ENCODE_START(5, 1, bl);
encode(access_key_id, bl);
encode(secret_access_key, bl);
encode(expiration, bl);
encode(policy, bl);
encode(roleId, bl);
encode(user, bl);
encode(acct_name, bl);
encode(perm_mask, bl);
encode(is_admin, bl);
encode(acct_type, bl);
encode(role_session, bl);
encode(token_claims, bl);
encode(issued_at, bl);
encode(principal_tags, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(5, bl);
decode(access_key_id, bl);
decode(secret_access_key, bl);
decode(expiration, bl);
decode(policy, bl);
decode(roleId, bl);
decode(user, bl);
decode(acct_name, bl);
decode(perm_mask, bl);
decode(is_admin, bl);
decode(acct_type, bl);
if (struct_v >= 2) {
decode(role_session, bl);
}
if (struct_v >= 3) {
decode(token_claims, bl);
}
if (struct_v >= 4) {
decode(issued_at, bl);
}
if (struct_v >= 5) {
decode(principal_tags, bl);
}
DECODE_FINISH(bl);
}
};
WRITE_CLASS_ENCODER(SessionToken)
class Credentials {
static constexpr int MAX_ACCESS_KEY_LEN = 20;
static constexpr int MAX_SECRET_KEY_LEN = 40;
std::string accessKeyId;
std::string expiration;
std::string secretAccessKey;
std::string sessionToken;
public:
int generateCredentials(const DoutPrefixProvider *dpp,
CephContext* cct,
const uint64_t& duration,
const boost::optional<std::string>& policy,
const boost::optional<std::string>& roleId,
const boost::optional<std::string>& role_session,
const boost::optional<std::vector<std::string>>& token_claims,
const boost::optional<std::vector<std::pair<std::string,std::string>>>& session_princ_tags,
boost::optional<rgw_user> user,
rgw::auth::Identity* identity);
const std::string& getAccessKeyId() const { return accessKeyId; }
const std::string& getExpiration() const { return expiration; }
const std::string& getSecretAccessKey() const { return secretAccessKey; }
const std::string& getSessionToken() const { return sessionToken; }
void dump(Formatter *f) const;
};
struct AssumeRoleResponse {
int retCode;
AssumedRoleUser user;
Credentials creds;
uint64_t packedPolicySize;
};
struct AssumeRoleWithWebIdentityResponse {
AssumeRoleResponse assumeRoleResp;
std::string aud;
std::string providerId;
std::string sub;
};
using AssumeRoleResponse = struct AssumeRoleResponse ;
using GetSessionTokenResponse = std::tuple<int, Credentials>;
using AssumeRoleWithWebIdentityResponse = struct AssumeRoleWithWebIdentityResponse;
class STSService {
CephContext* cct;
rgw::sal::Driver* driver;
rgw_user user_id;
std::unique_ptr<rgw::sal::RGWRole> role;
rgw::auth::Identity* identity;
public:
STSService() = default;
STSService(CephContext* cct, rgw::sal::Driver* driver, rgw_user user_id,
rgw::auth::Identity* identity)
: cct(cct), driver(driver), user_id(user_id), identity(identity) {}
std::tuple<int, rgw::sal::RGWRole*> getRoleInfo(const DoutPrefixProvider *dpp, const std::string& arn, optional_yield y);
AssumeRoleResponse assumeRole(const DoutPrefixProvider *dpp, AssumeRoleRequest& req, optional_yield y);
GetSessionTokenResponse getSessionToken(const DoutPrefixProvider *dpp, GetSessionTokenRequest& req);
AssumeRoleWithWebIdentityResponse assumeRoleWithWebIdentity(const DoutPrefixProvider *dpp, AssumeRoleWithWebIdentityRequest& req);
};
}
| 9,296 | 35.892857 | 132 |
h
|
null |
ceph-main/src/rgw/rgw_swift_auth.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#include <array>
#include <algorithm>
#include <string_view>
#include <boost/container/static_vector.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/algorithm/string.hpp>
#include "rgw_swift_auth.h"
#include "rgw_rest.h"
#include "common/ceph_crypto.h"
#include "common/Clock.h"
#include "include/random.h"
#include "rgw_client_io.h"
#include "rgw_http_client.h"
#include "rgw_sal_rados.h"
#include "include/str_list.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rgw
#define DEFAULT_SWIFT_PREFIX "/swift"
using namespace std;
using namespace ceph::crypto;
namespace rgw {
namespace auth {
namespace swift {
/* TempURL: applier */
void TempURLApplier::modify_request_state(const DoutPrefixProvider* dpp, req_state* s) const /* in/out */
{
bool inline_exists = false;
const std::string& filename = s->info.args.get("filename");
s->info.args.get("inline", &inline_exists);
if (inline_exists) {
s->content_disp.override = "inline";
} else if (!filename.empty()) {
std::string fenc;
url_encode(filename, fenc);
s->content_disp.override = "attachment; filename=\"" + fenc + "\"";
} else {
std::string fenc;
url_encode(s->object->get_name(), fenc);
s->content_disp.fallback = "attachment; filename=\"" + fenc + "\"";
}
ldpp_dout(dpp, 20) << "finished applying changes to req_state for TempURL: "
<< " content_disp override " << s->content_disp.override
<< " content_disp fallback " << s->content_disp.fallback
<< dendl;
}
void TempURLApplier::write_ops_log_entry(rgw_log_entry& entry) const
{
LocalApplier::write_ops_log_entry(entry);
entry.temp_url = true;
}
/* TempURL: engine */
bool TempURLEngine::is_applicable(const req_state* const s) const noexcept
{
return s->info.args.exists("temp_url_sig") ||
s->info.args.exists("temp_url_expires");
}
void TempURLEngine::get_owner_info(const DoutPrefixProvider* dpp, const req_state* const s,
RGWUserInfo& owner_info, optional_yield y) const
{
/* We cannot use req_state::bucket_name because it isn't available
* now. It will be initialized in RGWHandler_REST_SWIFT::postauth_init(). */
const string& bucket_name = s->init_state.url_bucket;
/* TempURL requires that bucket and object names are specified. */
if (bucket_name.empty() || s->object->empty()) {
throw -EPERM;
}
/* TempURL case is completely different than the Keystone auth - you may
* get account name only through extraction from URL. In turn, knowledge
* about account is neccessary to obtain its bucket tenant. Without that,
* the access would be limited to accounts with empty tenant. */
string bucket_tenant;
if (!s->account_name.empty()) {
bool found = false;
std::unique_ptr<rgw::sal::User> user;
rgw_user uid(s->account_name);
if (uid.tenant.empty()) {
rgw_user tenanted_uid(uid.id, uid.id);
user = driver->get_user(tenanted_uid);
if (user->load_user(dpp, s->yield) >= 0) {
/* Succeeded */
found = true;
}
}
if (!found) {
user = driver->get_user(uid);
if (user->load_user(dpp, s->yield) < 0) {
throw -EPERM;
}
}
bucket_tenant = user->get_tenant();
}
rgw_bucket b;
b.tenant = std::move(bucket_tenant);
b.name = std::move(bucket_name);
std::unique_ptr<rgw::sal::Bucket> bucket;
int ret = driver->get_bucket(dpp, nullptr, b, &bucket, s->yield);
if (ret < 0) {
throw ret;
}
ldpp_dout(dpp, 20) << "temp url user (bucket owner): " << bucket->get_info().owner
<< dendl;
std::unique_ptr<rgw::sal::User> user;
user = driver->get_user(bucket->get_info().owner);
if (user->load_user(dpp, s->yield) < 0) {
throw -EPERM;
}
owner_info = user->get_info();
}
std::string TempURLEngine::convert_from_iso8601(std::string expires) const
{
/* Swift's TempURL allows clients to send the expiration as ISO8601-
* compatible strings. Though, only plain UNIX timestamp are taken
* for the HMAC calculations. We need to make the conversion. */
struct tm date_t;
if (!parse_iso8601(expires.c_str(), &date_t, nullptr, true)) {
return expires;
} else {
return std::to_string(internal_timegm(&date_t));
}
}
bool TempURLEngine::is_expired(const std::string& expires) const
{
string err;
const utime_t now = ceph_clock_now();
const uint64_t expiration = (uint64_t)strict_strtoll(expires.c_str(),
10, &err);
if (!err.empty()) {
dout(5) << "failed to parse temp_url_expires: " << err << dendl;
return true;
}
if (expiration <= (uint64_t)now.sec()) {
dout(5) << "temp url expired: " << expiration << " <= " << now.sec() << dendl;
return true;
}
return false;
}
bool TempURLEngine::is_disallowed_header_present(const req_info& info) const
{
static const auto headers = {
"HTTP_X_OBJECT_MANIFEST",
};
return std::any_of(std::begin(headers), std::end(headers),
[&info](const char* header) {
return info.env->exists(header);
});
}
std::string extract_swift_subuser(const std::string& swift_user_name)
{
size_t pos = swift_user_name.find(':');
if (std::string::npos == pos) {
return swift_user_name;
} else {
return swift_user_name.substr(pos + 1);
}
}
class TempURLEngine::SignatureHelper
{
private:
static constexpr uint32_t output_size =
CEPH_CRYPTO_HMACSHA1_DIGESTSIZE * 2 + 1;
unsigned char dest[CEPH_CRYPTO_HMACSHA1_DIGESTSIZE]; // 20
char dest_str[output_size];
public:
SignatureHelper() = default;
const char* calc(const std::string& key,
const std::string_view& method,
const std::string_view& path,
const std::string& expires) {
using ceph::crypto::HMACSHA1;
using UCHARPTR = const unsigned char*;
HMACSHA1 hmac((UCHARPTR) key.c_str(), key.size());
hmac.Update((UCHARPTR) method.data(), method.size());
hmac.Update((UCHARPTR) "\n", 1);
hmac.Update((UCHARPTR) expires.c_str(), expires.size());
hmac.Update((UCHARPTR) "\n", 1);
hmac.Update((UCHARPTR) path.data(), path.size());
hmac.Final(dest);
buf_to_hex((UCHARPTR) dest, sizeof(dest), dest_str);
return dest_str;
}
bool is_equal_to(const std::string& rhs) const {
/* never allow out-of-range exception */
if (rhs.size() < (output_size - 1)) {
return false;
}
return rhs.compare(0 /* pos */, output_size, dest_str) == 0;
}
}; /* TempURLEngine::SignatureHelper */
class TempURLEngine::PrefixableSignatureHelper
: private TempURLEngine::SignatureHelper {
using base_t = SignatureHelper;
const std::string_view decoded_uri;
const std::string_view object_name;
std::string_view no_obj_uri;
const boost::optional<const std::string&> prefix;
public:
PrefixableSignatureHelper(const std::string& _decoded_uri,
const std::string& object_name,
const boost::optional<const std::string&> prefix)
: decoded_uri(_decoded_uri),
object_name(object_name),
prefix(prefix) {
/* Transform: v1/acct/cont/obj - > v1/acct/cont/
*
* NOTE(rzarzynski): we really want to substr() on std::string_view,
* not std::string. Otherwise we would end with no_obj_uri referencing
* a temporary. */
no_obj_uri = \
decoded_uri.substr(0, decoded_uri.length() - object_name.length());
}
const char* calc(const std::string& key,
const std::string_view& method,
const std::string_view& path,
const std::string& expires) {
if (!prefix) {
return base_t::calc(key, method, path, expires);
} else {
const auto prefixed_path = \
string_cat_reserve("prefix:", no_obj_uri, *prefix);
return base_t::calc(key, method, prefixed_path, expires);
}
}
bool is_equal_to(const std::string& rhs) const {
bool is_auth_ok = base_t::is_equal_to(rhs);
if (prefix && is_auth_ok) {
const auto prefix_uri = string_cat_reserve(no_obj_uri, *prefix);
is_auth_ok = boost::algorithm::starts_with(decoded_uri, prefix_uri);
}
return is_auth_ok;
}
}; /* TempURLEngine::PrefixableSignatureHelper */
TempURLEngine::result_t
TempURLEngine::authenticate(const DoutPrefixProvider* dpp, const req_state* const s, optional_yield y) const
{
if (! is_applicable(s)) {
return result_t::deny();
}
/* NOTE(rzarzynski): RGWHTTPArgs::get(), in contrast to RGWEnv::get(),
* never returns nullptr. If the requested parameter is absent, we will
* get the empty string. */
const std::string& temp_url_sig = s->info.args.get("temp_url_sig");
const std::string& temp_url_expires = \
convert_from_iso8601(s->info.args.get("temp_url_expires"));
if (temp_url_sig.empty() || temp_url_expires.empty()) {
return result_t::deny();
}
/* Though, for prefixed tempurls we need to differentiate between empty
* prefix and lack of prefix. Empty prefix means allowance for whole
* container. */
const boost::optional<const std::string&> temp_url_prefix = \
s->info.args.get_optional("temp_url_prefix");
RGWUserInfo owner_info;
try {
get_owner_info(dpp, s, owner_info, y);
} catch (...) {
ldpp_dout(dpp, 5) << "cannot get user_info of account's owner" << dendl;
return result_t::reject();
}
if (owner_info.temp_url_keys.empty()) {
ldpp_dout(dpp, 5) << "user does not have temp url key set, aborting" << dendl;
return result_t::reject();
}
if (is_expired(temp_url_expires)) {
ldpp_dout(dpp, 5) << "temp url link expired" << dendl;
return result_t::reject(-EPERM);
}
if (is_disallowed_header_present(s->info)) {
ldout(cct, 5) << "temp url rejected due to disallowed header" << dendl;
return result_t::reject(-EINVAL);
}
/* We need to verify two paths because of compliance with Swift, Tempest
* and old versions of RadosGW. The second item will have the prefix
* of Swift API entry point removed. */
/* XXX can we search this ONCE? */
const size_t pos = g_conf()->rgw_swift_url_prefix.find_last_not_of('/') + 1;
const std::string_view ref_uri = s->decoded_uri;
const std::array<std::string_view, 2> allowed_paths = {
ref_uri,
ref_uri.substr(pos + 1)
};
/* Account owner calculates the signature also against a HTTP method. */
boost::container::static_vector<std::string_view, 3> allowed_methods;
if (strcmp("HEAD", s->info.method) == 0) {
/* HEAD requests are specially handled. */
/* TODO: after getting a newer boost (with static_vector supporting
* initializers lists), get back to the good notation:
* allowed_methods = {"HEAD", "GET", "PUT" };
* Just for now let's use emplace_back to construct the vector. */
allowed_methods.emplace_back("HEAD");
allowed_methods.emplace_back("GET");
allowed_methods.emplace_back("PUT");
} else if (strlen(s->info.method) > 0) {
allowed_methods.emplace_back(s->info.method);
}
/* Need to try each combination of keys, allowed path and methods. */
PrefixableSignatureHelper sig_helper {
s->decoded_uri,
s->object->get_name(),
temp_url_prefix
};
for (const auto& kv : owner_info.temp_url_keys) {
const int temp_url_key_num = kv.first;
const string& temp_url_key = kv.second;
if (temp_url_key.empty()) {
continue;
}
for (const auto& path : allowed_paths) {
for (const auto& method : allowed_methods) {
const char* const local_sig = sig_helper.calc(temp_url_key, method,
path, temp_url_expires);
ldpp_dout(dpp, 20) << "temp url signature [" << temp_url_key_num
<< "] (calculated): " << local_sig
<< dendl;
if (sig_helper.is_equal_to(temp_url_sig)) {
auto apl = apl_factory->create_apl_turl(cct, s, owner_info);
return result_t::grant(std::move(apl));
} else {
ldpp_dout(dpp, 5) << "temp url signature mismatch: " << local_sig
<< " != " << temp_url_sig << dendl;
}
}
}
}
return result_t::reject();
}
/* External token */
bool ExternalTokenEngine::is_applicable(const std::string& token) const noexcept
{
if (token.empty()) {
return false;
} else if (g_conf()->rgw_swift_auth_url.empty()) {
return false;
} else {
return true;
}
}
ExternalTokenEngine::result_t
ExternalTokenEngine::authenticate(const DoutPrefixProvider* dpp,
const std::string& token,
const req_state* const s, optional_yield y) const
{
if (! is_applicable(token)) {
return result_t::deny();
}
std::string auth_url = g_conf()->rgw_swift_auth_url;
if (auth_url.back() != '/') {
auth_url.append("/");
}
auth_url.append("token");
char url_buf[auth_url.size() + 1 + token.length() + 1];
sprintf(url_buf, "%s/%s", auth_url.c_str(), token.c_str());
RGWHTTPHeadersCollector validator(cct, "GET", url_buf, { "X-Auth-Groups", "X-Auth-Ttl" });
ldpp_dout(dpp, 10) << "rgw_swift_validate_token url=" << url_buf << dendl;
int ret = validator.process(y);
if (ret < 0) {
throw ret;
}
std::string swift_user;
try {
std::vector<std::string> swift_groups;
get_str_vec(validator.get_header_value("X-Auth-Groups"),
",", swift_groups);
if (0 == swift_groups.size()) {
return result_t::deny(-EPERM);
} else {
swift_user = std::move(swift_groups[0]);
}
} catch (const std::out_of_range&) {
/* The X-Auth-Groups header isn't present in the response. */
return result_t::deny(-EPERM);
}
if (swift_user.empty()) {
return result_t::deny(-EPERM);
}
ldpp_dout(dpp, 10) << "swift user=" << swift_user << dendl;
std::unique_ptr<rgw::sal::User> user;
ret = driver->get_user_by_swift(dpp, swift_user, s->yield, &user);
if (ret < 0) {
ldpp_dout(dpp, 0) << "NOTICE: couldn't map swift user" << dendl;
throw ret;
}
auto apl = apl_factory->create_apl_local(cct, s, user->get_info(),
extract_swift_subuser(swift_user),
std::nullopt, rgw::auth::LocalApplier::NO_ACCESS_KEY);
return result_t::grant(std::move(apl));
}
static int build_token(const string& swift_user,
const string& key,
const uint64_t nonce,
const utime_t& expiration,
bufferlist& bl)
{
using ceph::encode;
encode(swift_user, bl);
encode(nonce, bl);
encode(expiration, bl);
bufferptr p(CEPH_CRYPTO_HMACSHA1_DIGESTSIZE);
char buf[bl.length() * 2 + 1];
buf_to_hex((const unsigned char *)bl.c_str(), bl.length(), buf);
dout(20) << "build_token token=" << buf << dendl;
char k[CEPH_CRYPTO_HMACSHA1_DIGESTSIZE];
// FIPS zeroization audit 20191116: this memset is not intended to
// wipe out a secret after use.
memset(k, 0, sizeof(k));
const char *s = key.c_str();
for (int i = 0; i < (int)key.length(); i++, s++) {
k[i % CEPH_CRYPTO_HMACSHA1_DIGESTSIZE] |= *s;
}
calc_hmac_sha1(k, sizeof(k), bl.c_str(), bl.length(), p.c_str());
::ceph::crypto::zeroize_for_security(k, sizeof(k));
bl.append(p);
return 0;
}
static int encode_token(CephContext *cct, string& swift_user, string& key,
bufferlist& bl)
{
const auto nonce = ceph::util::generate_random_number<uint64_t>();
utime_t expiration = ceph_clock_now();
expiration += cct->_conf->rgw_swift_token_expiration;
return build_token(swift_user, key, nonce, expiration, bl);
}
/* AUTH_rgwtk (signed token): engine */
bool SignedTokenEngine::is_applicable(const std::string& token) const noexcept
{
if (token.empty()) {
return false;
} else {
return token.compare(0, 10, "AUTH_rgwtk") == 0;
}
}
SignedTokenEngine::result_t
SignedTokenEngine::authenticate(const DoutPrefixProvider* dpp,
const std::string& token,
const req_state* const s) const
{
if (! is_applicable(token)) {
return result_t::deny(-EPERM);
}
/* Effective token string is the part after the prefix. */
const std::string etoken = token.substr(strlen("AUTH_rgwtk"));
const size_t etoken_len = etoken.length();
if (etoken_len & 1) {
ldpp_dout(dpp, 0) << "NOTICE: failed to verify token: odd token length="
<< etoken_len << dendl;
throw -EINVAL;
}
ceph::bufferptr p(etoken_len/2);
int ret = hex_to_buf(etoken.c_str(), p.c_str(), etoken_len);
if (ret < 0) {
throw ret;
}
ceph::bufferlist tok_bl;
tok_bl.append(p);
uint64_t nonce;
utime_t expiration;
std::string swift_user;
try {
auto iter = tok_bl.cbegin();
using ceph::decode;
decode(swift_user, iter);
decode(nonce, iter);
decode(expiration, iter);
} catch (buffer::error& err) {
ldpp_dout(dpp, 0) << "NOTICE: failed to decode token" << dendl;
throw -EINVAL;
}
const utime_t now = ceph_clock_now();
if (expiration < now) {
ldpp_dout(dpp, 0) << "NOTICE: old timed out token was used now=" << now
<< " token.expiration=" << expiration
<< dendl;
return result_t::deny(-EPERM);
}
std::unique_ptr<rgw::sal::User> user;
ret = driver->get_user_by_swift(dpp, swift_user, s->yield, &user);
if (ret < 0) {
throw ret;
}
ldpp_dout(dpp, 10) << "swift_user=" << swift_user << dendl;
const auto siter = user->get_info().swift_keys.find(swift_user);
if (siter == std::end(user->get_info().swift_keys)) {
return result_t::deny(-EPERM);
}
const auto swift_key = siter->second;
bufferlist local_tok_bl;
ret = build_token(swift_user, swift_key.key, nonce, expiration, local_tok_bl);
if (ret < 0) {
throw ret;
}
if (local_tok_bl.length() != tok_bl.length()) {
ldpp_dout(dpp, 0) << "NOTICE: tokens length mismatch:"
<< " tok_bl.length()=" << tok_bl.length()
<< " local_tok_bl.length()=" << local_tok_bl.length()
<< dendl;
return result_t::deny(-EPERM);
}
if (memcmp(local_tok_bl.c_str(), tok_bl.c_str(),
local_tok_bl.length()) != 0) {
char buf[local_tok_bl.length() * 2 + 1];
buf_to_hex(reinterpret_cast<const unsigned char *>(local_tok_bl.c_str()),
local_tok_bl.length(), buf);
ldpp_dout(dpp, 0) << "NOTICE: tokens mismatch tok=" << buf << dendl;
return result_t::deny(-EPERM);
}
auto apl = apl_factory->create_apl_local(cct, s, user->get_info(),
extract_swift_subuser(swift_user),
std::nullopt, rgw::auth::LocalApplier::NO_ACCESS_KEY);
return result_t::grant(std::move(apl));
}
} /* namespace swift */
} /* namespace auth */
} /* namespace rgw */
void RGW_SWIFT_Auth_Get::execute(optional_yield y)
{
int ret = -EPERM;
const char *key = s->info.env->get("HTTP_X_AUTH_KEY");
const char *user_name = s->info.env->get("HTTP_X_AUTH_USER");
s->prot_flags |= RGW_REST_SWIFT;
string user_str;
std::unique_ptr<rgw::sal::User> user;
bufferlist bl;
RGWAccessKey *swift_key;
map<string, RGWAccessKey>::iterator siter;
string swift_url = g_conf()->rgw_swift_url;
string swift_prefix = g_conf()->rgw_swift_url_prefix;
string tenant_path;
/*
* We did not allow an empty Swift prefix before, but we want it now.
* So, we take rgw_swift_url_prefix = "/" to yield the empty prefix.
* The rgw_swift_url_prefix = "" is the default and yields "/swift"
* in a backwards-compatible way.
*/
if (swift_prefix.size() == 0) {
swift_prefix = DEFAULT_SWIFT_PREFIX;
} else if (swift_prefix == "/") {
swift_prefix.clear();
} else {
if (swift_prefix[0] != '/') {
swift_prefix.insert(0, "/");
}
}
if (swift_url.size() == 0) {
bool add_port = false;
auto server_port = s->info.env->get_optional("SERVER_PORT_SECURE");
const char *protocol;
if (server_port) {
add_port = (*server_port != "443");
protocol = "https";
} else {
server_port = s->info.env->get_optional("SERVER_PORT");
if (server_port) {
add_port = (*server_port != "80");
}
protocol = "http";
}
const char *host = s->info.env->get("HTTP_HOST");
if (!host) {
dout(0) << "NOTICE: server is misconfigured, missing rgw_swift_url_prefix or rgw_swift_url, HTTP_HOST is not set" << dendl;
ret = -EINVAL;
goto done;
}
swift_url = protocol;
swift_url.append("://");
swift_url.append(host);
if (add_port && !strchr(host, ':')) {
swift_url.append(":");
swift_url.append(*server_port);
}
}
if (!key || !user_name)
goto done;
user_str = user_name;
ret = driver->get_user_by_swift(s, user_str, s->yield, &user);
if (ret < 0) {
ret = -EACCES;
goto done;
}
siter = user->get_info().swift_keys.find(user_str);
if (siter == user->get_info().swift_keys.end()) {
ret = -EPERM;
goto done;
}
swift_key = &siter->second;
if (swift_key->key.compare(key) != 0) {
dout(0) << "NOTICE: RGW_SWIFT_Auth_Get::execute(): bad swift key" << dendl;
ret = -EPERM;
goto done;
}
if (!g_conf()->rgw_swift_tenant_name.empty()) {
tenant_path = "/AUTH_";
tenant_path.append(g_conf()->rgw_swift_tenant_name);
} else if (g_conf()->rgw_swift_account_in_url) {
tenant_path = "/AUTH_";
tenant_path.append(user->get_id().to_str());
}
dump_header(s, "X-Storage-Url", swift_url + swift_prefix + "/v1" +
tenant_path);
using rgw::auth::swift::encode_token;
if ((ret = encode_token(s->cct, swift_key->id, swift_key->key, bl)) < 0)
goto done;
{
static constexpr size_t PREFIX_LEN = sizeof("AUTH_rgwtk") - 1;
char token_val[PREFIX_LEN + bl.length() * 2 + 1];
snprintf(token_val, PREFIX_LEN + 1, "AUTH_rgwtk");
buf_to_hex((const unsigned char *)bl.c_str(), bl.length(),
token_val + PREFIX_LEN);
dump_header(s, "X-Storage-Token", token_val);
dump_header(s, "X-Auth-Token", token_val);
}
ret = STATUS_NO_CONTENT;
done:
set_req_state_err(s, ret);
dump_errno(s);
end_header(s);
}
int RGWHandler_SWIFT_Auth::init(rgw::sal::Driver* driver, req_state *state,
rgw::io::BasicClient *cio)
{
state->dialect = "swift-auth";
state->formatter = new JSONFormatter;
state->format = RGWFormat::JSON;
return RGWHandler::init(driver, state, cio);
}
int RGWHandler_SWIFT_Auth::authorize(const DoutPrefixProvider *dpp, optional_yield)
{
return 0;
}
RGWOp *RGWHandler_SWIFT_Auth::op_get()
{
return new RGW_SWIFT_Auth_Get;
}
| 22,983 | 28.618557 | 129 |
cc
|
null |
ceph-main/src/rgw/rgw_swift_auth.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#pragma once
#include "rgw_common.h"
#include "rgw_user.h"
#include "rgw_op.h"
#include "rgw_rest.h"
#include "rgw_auth.h"
#include "rgw_auth_keystone.h"
#include "rgw_auth_filters.h"
#include "rgw_sal.h"
#define RGW_SWIFT_TOKEN_EXPIRATION (15 * 60)
namespace rgw {
namespace auth {
namespace swift {
/* TempURL: applier. */
class TempURLApplier : public rgw::auth::LocalApplier {
public:
TempURLApplier(CephContext* const cct,
const RGWUserInfo& user_info)
: LocalApplier(cct, user_info, LocalApplier::NO_SUBUSER, std::nullopt, LocalApplier::NO_ACCESS_KEY) {
};
void modify_request_state(const DoutPrefixProvider* dpp, req_state * s) const override; /* in/out */
void write_ops_log_entry(rgw_log_entry& entry) const override;
struct Factory {
virtual ~Factory() {}
virtual aplptr_t create_apl_turl(CephContext* cct,
const req_state* s,
const RGWUserInfo& user_info) const = 0;
};
};
/* TempURL: engine */
class TempURLEngine : public rgw::auth::Engine {
using result_t = rgw::auth::Engine::result_t;
CephContext* const cct;
rgw::sal::Driver* driver;
const TempURLApplier::Factory* const apl_factory;
/* Helper methods. */
void get_owner_info(const DoutPrefixProvider* dpp,
const req_state* s,
RGWUserInfo& owner_info,
optional_yield y) const;
std::string convert_from_iso8601(std::string expires) const;
bool is_applicable(const req_state* s) const noexcept;
bool is_expired(const std::string& expires) const;
bool is_disallowed_header_present(const req_info& info) const;
class SignatureHelper;
class PrefixableSignatureHelper;
public:
TempURLEngine(CephContext* const cct,
rgw::sal::Driver* _driver ,
const TempURLApplier::Factory* const apl_factory)
: cct(cct),
driver(_driver),
apl_factory(apl_factory) {
}
/* Interface implementations. */
const char* get_name() const noexcept override {
return "rgw::auth::swift::TempURLEngine";
}
result_t authenticate(const DoutPrefixProvider* dpp, const req_state* const s, optional_yield y) const override;
};
/* AUTH_rgwtk */
class SignedTokenEngine : public rgw::auth::Engine {
using result_t = rgw::auth::Engine::result_t;
CephContext* const cct;
rgw::sal::Driver* driver;
const rgw::auth::TokenExtractor* const extractor;
const rgw::auth::LocalApplier::Factory* const apl_factory;
bool is_applicable(const std::string& token) const noexcept;
using rgw::auth::Engine::authenticate;
result_t authenticate(const DoutPrefixProvider* dpp,
const std::string& token,
const req_state* s) const;
public:
SignedTokenEngine(CephContext* const cct,
rgw::sal::Driver* _driver,
const rgw::auth::TokenExtractor* const extractor,
const rgw::auth::LocalApplier::Factory* const apl_factory)
: cct(cct),
driver(_driver),
extractor(extractor),
apl_factory(apl_factory) {
}
const char* get_name() const noexcept override {
return "rgw::auth::swift::SignedTokenEngine";
}
result_t authenticate(const DoutPrefixProvider* dpp, const req_state* const s,
optional_yield y) const override {
return authenticate(dpp, extractor->get_token(s), s);
}
};
/* External token */
class ExternalTokenEngine : public rgw::auth::Engine {
using result_t = rgw::auth::Engine::result_t;
CephContext* const cct;
rgw::sal::Driver* driver;
const rgw::auth::TokenExtractor* const extractor;
const rgw::auth::LocalApplier::Factory* const apl_factory;
bool is_applicable(const std::string& token) const noexcept;
result_t authenticate(const DoutPrefixProvider* dpp,
const std::string& token,
const req_state* s, optional_yield y) const;
public:
ExternalTokenEngine(CephContext* const cct,
rgw::sal::Driver* _driver,
const rgw::auth::TokenExtractor* const extractor,
const rgw::auth::LocalApplier::Factory* const apl_factory)
: cct(cct),
driver(_driver),
extractor(extractor),
apl_factory(apl_factory) {
}
const char* get_name() const noexcept override {
return "rgw::auth::swift::ExternalTokenEngine";
}
result_t authenticate(const DoutPrefixProvider* dpp, const req_state* const s,
optional_yield y) const override {
return authenticate(dpp, extractor->get_token(s), s, y);
}
};
/* SwiftAnonymous: applier. */
class SwiftAnonymousApplier : public rgw::auth::LocalApplier {
public:
SwiftAnonymousApplier(CephContext* const cct,
const RGWUserInfo& user_info)
: LocalApplier(cct, user_info, LocalApplier::NO_SUBUSER, std::nullopt, LocalApplier::NO_ACCESS_KEY) {
}
bool is_admin_of(const rgw_user& uid) const {return false;}
bool is_owner_of(const rgw_user& uid) const {return uid.id.compare(RGW_USER_ANON_ID) == 0;}
};
class SwiftAnonymousEngine : public rgw::auth::AnonymousEngine {
const rgw::auth::TokenExtractor* const extractor;
bool is_applicable(const req_state* s) const noexcept override {
return extractor->get_token(s).empty();
}
public:
SwiftAnonymousEngine(CephContext* const cct,
const SwiftAnonymousApplier::Factory* const apl_factory,
const rgw::auth::TokenExtractor* const extractor)
: AnonymousEngine(cct, apl_factory),
extractor(extractor) {
}
const char* get_name() const noexcept override {
return "rgw::auth::swift::SwiftAnonymousEngine";
}
};
class DefaultStrategy : public rgw::auth::Strategy,
public rgw::auth::RemoteApplier::Factory,
public rgw::auth::LocalApplier::Factory,
public rgw::auth::swift::TempURLApplier::Factory {
rgw::sal::Driver* driver;
const ImplicitTenants& implicit_tenant_context;
/* The engines. */
const rgw::auth::swift::TempURLEngine tempurl_engine;
const rgw::auth::swift::SignedTokenEngine signed_engine;
boost::optional <const rgw::auth::keystone::TokenEngine> keystone_engine;
const rgw::auth::swift::ExternalTokenEngine external_engine;
const rgw::auth::swift::SwiftAnonymousEngine anon_engine;
using keystone_config_t = rgw::keystone::CephCtxConfig;
using keystone_cache_t = rgw::keystone::TokenCache;
using aplptr_t = rgw::auth::IdentityApplier::aplptr_t;
using acl_strategy_t = rgw::auth::RemoteApplier::acl_strategy_t;
/* The method implements TokenExtractor for X-Auth-Token present in req_state. */
struct AuthTokenExtractor : rgw::auth::TokenExtractor {
std::string get_token(const req_state* const s) const override {
/* Returning a reference here would end in GCC complaining about a reference
* to temporary. */
return s->info.env->get("HTTP_X_AUTH_TOKEN", "");
}
} auth_token_extractor;
/* The method implements TokenExtractor for X-Service-Token present in req_state. */
struct ServiceTokenExtractor : rgw::auth::TokenExtractor {
std::string get_token(const req_state* const s) const override {
return s->info.env->get("HTTP_X_SERVICE_TOKEN", "");
}
} service_token_extractor;
aplptr_t create_apl_remote(CephContext* const cct,
const req_state* const s,
acl_strategy_t&& extra_acl_strategy,
const rgw::auth::RemoteApplier::AuthInfo &info) const override {
auto apl = \
rgw::auth::add_3rdparty(driver, rgw_user(s->account_name),
rgw::auth::add_sysreq(cct, driver, s,
rgw::auth::RemoteApplier(cct, driver, std::move(extra_acl_strategy), info,
implicit_tenant_context,
rgw::auth::ImplicitTenants::IMPLICIT_TENANTS_SWIFT)));
/* TODO(rzarzynski): replace with static_ptr. */
return aplptr_t(new decltype(apl)(std::move(apl)));
}
aplptr_t create_apl_local(CephContext* const cct,
const req_state* const s,
const RGWUserInfo& user_info,
const std::string& subuser,
const std::optional<uint32_t>& perm_mask,
const std::string& access_key_id) const override {
auto apl = \
rgw::auth::add_3rdparty(driver, rgw_user(s->account_name),
rgw::auth::add_sysreq(cct, driver, s,
rgw::auth::LocalApplier(cct, user_info, subuser, perm_mask, access_key_id)));
/* TODO(rzarzynski): replace with static_ptr. */
return aplptr_t(new decltype(apl)(std::move(apl)));
}
aplptr_t create_apl_turl(CephContext* const cct,
const req_state* const s,
const RGWUserInfo& user_info) const override {
/* TempURL doesn't need any user account override. It's a Swift-specific
* mechanism that requires account name internally, so there is no
* business with delegating the responsibility outside. */
return aplptr_t(new rgw::auth::swift::TempURLApplier(cct, user_info));
}
public:
DefaultStrategy(CephContext* const cct,
const ImplicitTenants& implicit_tenant_context,
rgw::sal::Driver* _driver)
: driver(_driver),
implicit_tenant_context(implicit_tenant_context),
tempurl_engine(cct,
driver,
static_cast<rgw::auth::swift::TempURLApplier::Factory*>(this)),
signed_engine(cct,
driver,
static_cast<rgw::auth::TokenExtractor*>(&auth_token_extractor),
static_cast<rgw::auth::LocalApplier::Factory*>(this)),
external_engine(cct,
driver,
static_cast<rgw::auth::TokenExtractor*>(&auth_token_extractor),
static_cast<rgw::auth::LocalApplier::Factory*>(this)),
anon_engine(cct,
static_cast<SwiftAnonymousApplier::Factory*>(this),
static_cast<rgw::auth::TokenExtractor*>(&auth_token_extractor)) {
/* When the constructor's body is being executed, all member engines
* should be initialized. Thus, we can safely add them. */
using Control = rgw::auth::Strategy::Control;
add_engine(Control::SUFFICIENT, tempurl_engine);
add_engine(Control::SUFFICIENT, signed_engine);
/* The auth strategy is responsible for deciding whether a parcular
* engine is disabled or not. */
if (! cct->_conf->rgw_keystone_url.empty()) {
keystone_engine.emplace(cct,
static_cast<rgw::auth::TokenExtractor*>(&auth_token_extractor),
static_cast<rgw::auth::TokenExtractor*>(&service_token_extractor),
static_cast<rgw::auth::RemoteApplier::Factory*>(this),
keystone_config_t::get_instance(),
keystone_cache_t::get_instance<keystone_config_t>());
add_engine(Control::SUFFICIENT, *keystone_engine);
}
if (! cct->_conf->rgw_swift_auth_url.empty()) {
add_engine(Control::SUFFICIENT, external_engine);
}
add_engine(Control::SUFFICIENT, anon_engine);
}
const char* get_name() const noexcept override {
return "rgw::auth::swift::DefaultStrategy";
}
};
} /* namespace swift */
} /* namespace auth */
} /* namespace rgw */
class RGW_SWIFT_Auth_Get : public RGWOp {
public:
RGW_SWIFT_Auth_Get() {}
~RGW_SWIFT_Auth_Get() override {}
int verify_permission(optional_yield) override { return 0; }
void execute(optional_yield y) override;
const char* name() const override { return "swift_auth_get"; }
dmc::client_id dmclock_client() override { return dmc::client_id::auth; }
};
class RGWHandler_SWIFT_Auth : public RGWHandler_REST {
public:
RGWHandler_SWIFT_Auth() {}
~RGWHandler_SWIFT_Auth() override {}
RGWOp *op_get() override;
int init(rgw::sal::Driver* driver, req_state *state, rgw::io::BasicClient *cio) override;
int authorize(const DoutPrefixProvider *dpp, optional_yield y) override;
int postauth_init(optional_yield) override { return 0; }
int read_permissions(RGWOp *op, optional_yield) override { return 0; }
virtual RGWAccessControlPolicy *alloc_policy() { return NULL; }
virtual void free_policy(RGWAccessControlPolicy *policy) {}
};
class RGWRESTMgr_SWIFT_Auth : public RGWRESTMgr {
public:
RGWRESTMgr_SWIFT_Auth() = default;
~RGWRESTMgr_SWIFT_Auth() override = default;
RGWRESTMgr *get_resource_mgr(req_state* const s,
const std::string& uri,
std::string* const out_uri) override {
return this;
}
RGWHandler_REST* get_handler(rgw::sal::Driver* driver,
req_state*,
const rgw::auth::StrategyRegistry&,
const std::string&) override {
return new RGWHandler_SWIFT_Auth;
}
};
| 13,237 | 36.290141 | 114 |
h
|
null |
ceph-main/src/rgw/rgw_sync.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#include "rgw_sync.h"
#define dout_subsys ceph_subsys_rgw
using namespace std;
std::ostream& RGWMetaSyncStatusManager::gen_prefix(std::ostream& out) const
{
return out << "meta sync: ";
}
unsigned RGWMetaSyncStatusManager::get_subsys() const
{
return dout_subsys;
}
void RGWRemoteMetaLog::finish()
{
going_down = true;
stop();
}
| 448 | 17.708333 | 76 |
cc
|
null |
ceph-main/src/rgw/rgw_sync_checkpoint.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2020 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <fmt/format.h>
#include "common/errno.h"
#include "rgw_sync_checkpoint.h"
#include "rgw_sal_rados.h"
#include "rgw_bucket_sync.h"
#include "rgw_data_sync.h"
#include "rgw_http_errors.h"
#include "cls/rgw/cls_rgw_client.h"
#include "services/svc_sys_obj.h"
#include "services/svc_zone.h"
#include "rgw_zone.h"
#define dout_subsys ceph_subsys_rgw
namespace {
std::string incremental_marker(const rgw_bucket_shard_sync_info& info)
{
return BucketIndexShardsManager::get_shard_marker(info.inc_marker.position);
}
bool operator<(const std::vector<rgw_bucket_shard_sync_info>& lhs,
const BucketIndexShardsManager& rhs)
{
for (size_t i = 0; i < lhs.size(); ++i) {
const auto& l = incremental_marker(lhs[i]);
const auto& r = rhs.get(i, "");
if (l < r) {
return true;
}
}
return false;
}
bool empty(const BucketIndexShardsManager& markers, int size)
{
static const std::string empty_string;
for (int i = 0; i < size; ++i) {
const auto& m = markers.get(i, empty_string);
if (!m.empty()) {
return false;
}
}
return true;
}
std::ostream& operator<<(std::ostream& out, const std::vector<rgw_bucket_shard_sync_info>& rhs)
{
const char* separator = ""; // first entry has no comma
out << '[';
for (auto& i : rhs) {
out << std::exchange(separator, ", ") << incremental_marker(i);
}
return out << ']';
}
std::ostream& operator<<(std::ostream& out, const BucketIndexShardsManager& rhs)
{
out << '[';
const char* separator = ""; // first entry has no comma
for (auto& [i, marker] : rhs.get()) {
out << std::exchange(separator, ", ") << marker;
}
return out << ']';
}
int bucket_source_sync_checkpoint(const DoutPrefixProvider* dpp,
rgw::sal::RadosStore* store,
const RGWBucketInfo& bucket_info,
const RGWBucketInfo& source_bucket_info,
const rgw_sync_bucket_pipe& pipe,
uint64_t latest_gen,
const BucketIndexShardsManager& remote_markers,
ceph::timespan retry_delay,
ceph::coarse_mono_time timeout_at)
{
const int num_shards = remote_markers.get().size();
rgw_bucket_sync_status full_status;
int r = rgw_read_bucket_full_sync_status(dpp, store, pipe, &full_status, null_yield);
if (r < 0 && r != -ENOENT) { // retry on ENOENT
return r;
}
// wait for incremental
while (full_status.state != BucketSyncState::Incremental) {
const auto delay_until = ceph::coarse_mono_clock::now() + retry_delay;
if (delay_until > timeout_at) {
lderr(store->ctx()) << "bucket checkpoint timed out waiting to reach incremental sync" << dendl;
return -ETIMEDOUT;
}
ldout(store->ctx(), 1) << "waiting to reach incremental sync.." << dendl;
std::this_thread::sleep_until(delay_until);
r = rgw_read_bucket_full_sync_status(dpp, store, pipe, &full_status, null_yield);
if (r < 0 && r != -ENOENT) { // retry on ENOENT
return r;
}
}
// wait for latest_gen
while (full_status.incremental_gen < latest_gen) {
const auto delay_until = ceph::coarse_mono_clock::now() + retry_delay;
if (delay_until > timeout_at) {
lderr(store->ctx()) << "bucket checkpoint timed out waiting to reach "
"latest generation " << latest_gen << dendl;
return -ETIMEDOUT;
}
ldout(store->ctx(), 1) << "waiting to reach latest gen " << latest_gen
<< ", on " << full_status.incremental_gen << ".." << dendl;
std::this_thread::sleep_until(delay_until);
r = rgw_read_bucket_full_sync_status(dpp, store, pipe, &full_status, null_yield);
if (r < 0 && r != -ENOENT) { // retry on ENOENT
return r;
}
}
if (full_status.incremental_gen > latest_gen) {
ldpp_dout(dpp, 1) << "bucket sync caught up with source:\n"
<< " local gen: " << full_status.incremental_gen << '\n'
<< " remote gen: " << latest_gen << dendl;
return 0;
}
if (empty(remote_markers, num_shards)) {
ldpp_dout(dpp, 1) << "bucket sync caught up with empty source" << dendl;
return 0;
}
std::vector<rgw_bucket_shard_sync_info> status;
status.resize(std::max<size_t>(1, num_shards));
r = rgw_read_bucket_inc_sync_status(dpp, store, pipe,
full_status.incremental_gen, &status);
if (r < 0) {
return r;
}
while (status < remote_markers) {
const auto delay_until = ceph::coarse_mono_clock::now() + retry_delay;
if (delay_until > timeout_at) {
ldpp_dout(dpp, 0) << "bucket checkpoint timed out waiting for incremental sync to catch up" << dendl;
return -ETIMEDOUT;
}
ldpp_dout(dpp, 1) << "waiting for incremental sync to catch up:\n"
<< " local status: " << status << '\n'
<< " remote markers: " << remote_markers << dendl;
std::this_thread::sleep_until(delay_until);
r = rgw_read_bucket_inc_sync_status(dpp, store, pipe,
full_status.incremental_gen, &status);
if (r < 0) {
return r;
}
}
ldpp_dout(dpp, 1) << "bucket sync caught up with source:\n"
<< " local status: " << status << '\n'
<< " remote markers: " << remote_markers << dendl;
return 0;
}
int source_bilog_info(const DoutPrefixProvider *dpp,
RGWSI_Zone* zone_svc,
const rgw_sync_bucket_pipe& pipe,
rgw_bucket_index_marker_info& info,
BucketIndexShardsManager& markers,
optional_yield y)
{
ceph_assert(pipe.source.zone);
auto& zone_conn_map = zone_svc->get_zone_conn_map();
auto conn = zone_conn_map.find(pipe.source.zone->id);
if (conn == zone_conn_map.end()) {
return -EINVAL;
}
return rgw_read_remote_bilog_info(dpp, conn->second, *pipe.source.bucket,
info, markers, y);
}
} // anonymous namespace
int rgw_bucket_sync_checkpoint(const DoutPrefixProvider* dpp,
rgw::sal::RadosStore* store,
const RGWBucketSyncPolicyHandler& policy,
const RGWBucketInfo& info,
std::optional<rgw_zone_id> opt_source_zone,
std::optional<rgw_bucket> opt_source_bucket,
ceph::timespan retry_delay,
ceph::coarse_mono_time timeout_at)
{
struct sync_source_entry {
rgw_sync_bucket_pipe pipe;
uint64_t latest_gen = 0;
BucketIndexShardsManager remote_markers;
RGWBucketInfo source_bucket_info;
};
std::list<sync_source_entry> sources;
// fetch remote markers and bucket info in parallel
boost::asio::io_context ioctx;
for (const auto& [source_zone_id, pipe] : policy.get_all_sources()) {
// filter by source zone/bucket
if (opt_source_zone && *opt_source_zone != *pipe.source.zone) {
continue;
}
if (opt_source_bucket && !opt_source_bucket->match(*pipe.source.bucket)) {
continue;
}
auto& entry = sources.emplace_back();
entry.pipe = pipe;
// fetch remote markers
spawn::spawn(ioctx, [&] (yield_context yield) {
auto y = optional_yield{ioctx, yield};
rgw_bucket_index_marker_info info;
int r = source_bilog_info(dpp, store->svc()->zone, entry.pipe,
info, entry.remote_markers, y);
if (r < 0) {
ldpp_dout(dpp, 0) << "failed to fetch remote bilog markers: "
<< cpp_strerror(r) << dendl;
throw std::system_error(-r, std::system_category());
}
entry.latest_gen = info.latest_gen;
});
// fetch source bucket info
spawn::spawn(ioctx, [&] (yield_context yield) {
auto y = optional_yield{ioctx, yield};
int r = store->getRados()->get_bucket_instance_info(
*entry.pipe.source.bucket, entry.source_bucket_info,
nullptr, nullptr, y, dpp);
if (r < 0) {
ldpp_dout(dpp, 0) << "failed to read source bucket info: "
<< cpp_strerror(r) << dendl;
throw std::system_error(-r, std::system_category());
}
});
}
try {
ioctx.run();
} catch (const std::system_error& e) {
return -e.code().value();
}
// checkpoint each source sequentially
for (const auto& e : sources) {
int r = bucket_source_sync_checkpoint(dpp, store, info, e.source_bucket_info,
e.pipe, e.latest_gen, e.remote_markers,
retry_delay, timeout_at);
if (r < 0) {
ldpp_dout(dpp, 0) << "bucket sync checkpoint failed: " << cpp_strerror(r) << dendl;
return r;
}
}
ldpp_dout(dpp, 0) << "bucket checkpoint complete" << dendl;
return 0;
}
| 9,366 | 33.061818 | 107 |
cc
|
null |
ceph-main/src/rgw/rgw_sync_checkpoint.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2020 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#pragma once
#include <optional>
#include "common/ceph_time.h"
#include "rgw_basic_types.h"
class DoutPrefixProvider;
namespace rgw::sal { class RadosStore; }
class RGWBucketInfo;
class RGWBucketSyncPolicyHandler;
// poll the bucket's sync status until it's caught up against all sync sources
int rgw_bucket_sync_checkpoint(const DoutPrefixProvider* dpp,
rgw::sal::RadosStore* store,
const RGWBucketSyncPolicyHandler& policy,
const RGWBucketInfo& info,
std::optional<rgw_zone_id> opt_source_zone,
std::optional<rgw_bucket> opt_source_bucket,
ceph::timespan retry_delay,
ceph::coarse_mono_time timeout_at);
| 1,239 | 33.444444 | 78 |
h
|
null |
ceph-main/src/rgw/rgw_sync_policy.cc
|
#include "rgw_common.h"
#include "rgw_sync_policy.h"
#include "rgw_bucket.h"
#define dout_subsys ceph_subsys_rgw
using namespace std;
string rgw_sync_bucket_entity::bucket_key() const
{
return rgw_sync_bucket_entities::bucket_key(bucket);
}
bool rgw_sync_pipe_filter_tag::from_str(const string& s)
{
if (s.empty()) {
return false;
}
auto pos = s.find('=');
if (pos == string::npos) {
key = s;
return true;
}
key = s.substr(0, pos);
if (pos < s.size() - 1) {
value = s.substr(pos + 1);
}
return true;
}
bool rgw_sync_pipe_filter_tag::operator==(const string& s) const
{
if (s.empty()) {
return false;
}
auto pos = s.find('=');
if (pos == string::npos) {
return value.empty() && (s == key);
}
return s.compare(0, pos, s) == 0 &&
s.compare(pos + 1, s.size() - pos - 1, value) == 0;
}
void rgw_sync_pipe_filter::encode(bufferlist& bl) const
{
ENCODE_START(1, 1, bl);
encode(prefix, bl);
encode(tags, bl);
ENCODE_FINISH(bl);
}
void rgw_sync_pipe_filter::decode(bufferlist::const_iterator& bl)
{
DECODE_START(1, bl);
decode(prefix, bl);
decode(tags, bl);
DECODE_FINISH(bl);
}
void rgw_sync_pipe_filter::set_prefix(std::optional<std::string> opt_prefix,
bool prefix_rm)
{
if (opt_prefix) {
prefix = *opt_prefix;
} else if (prefix_rm) {
prefix.reset();
}
}
void rgw_sync_pipe_filter::set_tags(std::list<std::string>& tags_add,
std::list<std::string>& tags_rm)
{
for (auto& t : tags_rm) {
rgw_sync_pipe_filter_tag tag;
if (tag.from_str(t)) {
tags.erase(tag);
}
}
for (auto& t : tags_add) {
rgw_sync_pipe_filter_tag tag;
if (tag.from_str(t)) {
tags.insert(tag);
}
}
}
bool rgw_sync_pipe_filter::is_subset_of(const rgw_sync_pipe_filter& f) const
{
if (f.prefix) {
if (!prefix) {
return false;
}
/* f.prefix exists, and this->prefix is either equal or bigger,
* therefore this->prefix also set */
if (!boost::starts_with(*prefix, *f.prefix)) {
return false;
}
}
/* prefix is subset, now check tags. All our tags should exist in f.tags */
for (auto& t : tags) {
if (f.tags.find(t) == f.tags.end()) {
return false;
}
}
return true;
}
bool rgw_sync_pipe_filter::check_tag(const string& s) const
{
if (tags.empty()) { /* tag filter wasn't defined */
return true;
}
auto iter = tags.find(rgw_sync_pipe_filter_tag(s));
return (iter != tags.end());
}
bool rgw_sync_pipe_filter::check_tag(const string& k, const string& v) const
{
if (tags.empty()) { /* tag filter wasn't defined */
return true;
}
auto iter = tags.find(rgw_sync_pipe_filter_tag(k, v));
return (iter != tags.end());
}
bool rgw_sync_pipe_filter::has_tags() const
{
return !tags.empty();
}
bool rgw_sync_pipe_filter::check_tags(const std::vector<string>& _tags) const
{
if (tags.empty()) {
return true;
}
for (auto& t : _tags) {
if (check_tag(t)) {
return true;
}
}
return false;
}
bool rgw_sync_pipe_filter::check_tags(const RGWObjTags::tag_map_t& _tags) const
{
if (tags.empty()) {
return true;
}
for (auto& item : _tags) {
if (check_tag(item.first, item.second)) {
return true;
}
}
return false;
}
void rgw_sync_bucket_entity::apply_bucket(std::optional<rgw_bucket> b)
{
if (!b) {
return;
}
if (!bucket ||
bucket->name.empty()) {
bucket = b;
}
}
void rgw_sync_bucket_entities::add_zones(const std::vector<rgw_zone_id>& new_zones) {
for (auto& z : new_zones) {
if (z == "*") {
all_zones = true;
zones.reset();
return;
}
if (!zones) {
zones.emplace();
}
zones->insert(z);
all_zones = false;
}
}
std::vector<rgw_sync_bucket_entity> rgw_sync_bucket_entities::expand() const
{
std::vector<rgw_sync_bucket_entity> result;
rgw_bucket b = get_bucket();
if (all_zones) {
rgw_sync_bucket_entity e;
e.all_zones = true;
e.bucket = b;
result.push_back(e);
return result;
}
if (!zones) {
return result;
}
for (auto& z : *zones) {
rgw_sync_bucket_entity e;
e.all_zones = false;
e.bucket = b;
e.zone = z;
result.push_back(e);
}
return result;
}
void rgw_sync_bucket_entities::remove_zones(const std::vector<rgw_zone_id>& rm_zones) {
all_zones = false;
if (!zones) {
return;
}
for (auto& z : rm_zones) {
zones->erase(z);
}
}
static void set_bucket_field(std::optional<string> source, string *field) {
if (!source) {
return;
}
if (source == "*") {
field->clear();
return;
}
*field = *source;
}
void rgw_sync_bucket_entities::set_bucket(std::optional<string> tenant,
std::optional<string> bucket_name,
std::optional<string> bucket_id)
{
if ((!bucket) && (tenant || bucket_name || bucket_id)) {
bucket.emplace();
}
if (!bucket) {
return;
}
set_bucket_field(tenant, &bucket->tenant);
set_bucket_field(bucket_name, &bucket->name);
set_bucket_field(bucket_id, &bucket->bucket_id);
if (bucket->tenant.empty() &&
bucket->name.empty() &&
bucket->bucket_id.empty()) {
bucket.reset();
}
}
void rgw_sync_bucket_entities::remove_bucket(std::optional<string> tenant,
std::optional<string> bucket_name,
std::optional<string> bucket_id)
{
if (!bucket) {
return;
}
if (tenant) {
bucket->tenant.clear();
}
if (bucket_name) {
bucket->name.clear();
}
if (bucket_id) {
bucket->bucket_id.clear();
}
if (bucket->tenant.empty() &&
bucket->name.empty() &&
bucket->bucket_id.empty()) {
bucket.reset();
}
}
string rgw_sync_bucket_entities::bucket_key(std::optional<rgw_bucket> b)
{
if (!b) {
return string("*");
}
rgw_bucket _b = *b;
if (_b.name.empty()) {
_b.name = "*";
}
return _b.get_key();
}
std::vector<rgw_sync_bucket_pipe> rgw_sync_bucket_pipes::expand() const
{
std::vector<rgw_sync_bucket_pipe> result;
auto sources = source.expand();
auto dests = dest.expand();
for (auto& s : sources) {
for (auto& d : dests) {
rgw_sync_bucket_pipe pipe;
pipe.id = id;
pipe.source = s;
pipe.dest = d;
pipe.params = params;
result.push_back(pipe);
}
}
return result;
}
void rgw_sync_bucket_pipes::get_potential_related_buckets(const rgw_bucket& bucket,
std::set<rgw_bucket> *sources,
std::set<rgw_bucket> *dests) const
{
if (dest.match_bucket(bucket)) {
auto expanded_sources = source.expand();
for (auto& s : expanded_sources) {
if (s.bucket && !s.bucket->name.empty()) {
sources->insert(*s.bucket);
}
}
}
if (source.match_bucket(bucket)) {
auto expanded_dests = dest.expand();
for (auto& d : expanded_dests) {
if (d.bucket && !d.bucket->name.empty()) {
dests->insert(*d.bucket);
}
}
}
}
bool rgw_sync_data_flow_group::find_or_create_symmetrical(const string& flow_id, rgw_sync_symmetric_group **flow_group)
{
for (auto& group : symmetrical) {
if (flow_id == group.id) {
*flow_group = &group;
return true;
}
}
auto& group = symmetrical.emplace_back();
*flow_group = &group;
(*flow_group)->id = flow_id;
return true;
}
void rgw_sync_data_flow_group::remove_symmetrical(const string& flow_id, std::optional<std::vector<rgw_zone_id> > zones)
{
if (symmetrical.empty()) {
return;
}
auto& groups = symmetrical;
auto iter = groups.begin();
for (; iter != groups.end(); ++iter) {
if (iter->id == flow_id) {
if (!zones) {
groups.erase(iter);
if (groups.empty()) {
symmetrical.clear();
}
return;
}
break;
}
}
if (iter == groups.end()) {
return;
}
auto& flow_group = *iter;
for (auto& z : *zones) {
flow_group.zones.erase(z);
}
if (flow_group.zones.empty()) {
groups.erase(iter);
}
if (groups.empty()) {
symmetrical.clear();
}
}
bool rgw_sync_data_flow_group::find_or_create_directional(const rgw_zone_id& source_zone, const rgw_zone_id& dest_zone, rgw_sync_directional_rule **flow_group)
{
for (auto& rule : directional) {
if (source_zone == rule.source_zone &&
dest_zone == rule.dest_zone) {
*flow_group = &rule;
return true;
}
}
auto& rule = directional.emplace_back();
*flow_group = &rule;
rule.source_zone = source_zone;
rule.dest_zone = dest_zone;
return true;
}
void rgw_sync_data_flow_group::remove_directional(const rgw_zone_id& source_zone, const rgw_zone_id& dest_zone)
{
if (directional.empty()) {
return;
}
for (auto iter = directional.begin(); iter != directional.end(); ++iter) {
auto& rule = *iter;
if (source_zone == rule.source_zone &&
dest_zone == rule.dest_zone) {
directional.erase(iter);
return;
}
}
}
void rgw_sync_data_flow_group::init_default(const std::set<rgw_zone_id>& zones)
{
symmetrical.clear();
symmetrical.push_back(rgw_sync_symmetric_group("default", zones));
}
bool rgw_sync_policy_group::find_pipe(const string& pipe_id, bool create, rgw_sync_bucket_pipes **pipe)
{
for (auto& p : pipes) {
if (pipe_id == p.id) {
*pipe = &p;
return true;
}
}
if (!create) {
return false;
}
auto& p = pipes.emplace_back();
*pipe = &p;
p.id = pipe_id;
return true;
}
void rgw_sync_policy_group::remove_pipe(const string& pipe_id)
{
for (auto iter = pipes.begin(); iter != pipes.end(); ++iter) {
if (pipe_id == iter->id) {
pipes.erase(iter);
return;
}
}
}
void rgw_sync_policy_group::get_potential_related_buckets(const rgw_bucket& bucket,
std::set<rgw_bucket> *sources,
std::set<rgw_bucket> *dests) const
{
for (auto& pipe : pipes) {
pipe.get_potential_related_buckets(bucket, sources, dests);
}
}
void rgw_sync_policy_info::get_potential_related_buckets(const rgw_bucket& bucket,
std::set<rgw_bucket> *sources,
std::set<rgw_bucket> *dests) const
{
for (auto& entry : groups) {
auto& group = entry.second;
group.get_potential_related_buckets(bucket, sources, dests);
}
}
void rgw_sync_directional_rule::dump(Formatter *f) const
{
encode_json("source_zone", source_zone, f);
encode_json("dest_zone", dest_zone, f);
}
void rgw_sync_directional_rule::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("source_zone", source_zone, obj);
JSONDecoder::decode_json("dest_zone", dest_zone, obj);
}
void rgw_sync_symmetric_group::dump(Formatter *f) const
{
encode_json("id", id, f);
encode_json("zones", zones, f);
}
void rgw_sync_symmetric_group::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("id", id, obj);
JSONDecoder::decode_json("zones", zones, obj);
}
void rgw_sync_bucket_entity::dump(Formatter *f) const
{
encode_json("zone", zone, f);
encode_json("bucket", bucket_key(), f);
}
void rgw_sync_bucket_entity::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("zone", zone, obj);
string s;
if (JSONDecoder::decode_json("bucket", s, obj)) {
rgw_bucket b;
int ret = rgw_bucket_parse_bucket_key(nullptr, s, &b, nullptr);
if (ret >= 0) {
bucket = b;
} else {
bucket.reset();
}
}
}
void rgw_sync_pipe_filter_tag::dump(Formatter *f) const
{
encode_json("key", key, f);
encode_json("value", value, f);
}
void rgw_sync_pipe_filter_tag::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("key", key, obj);
JSONDecoder::decode_json("value", value, obj);
}
void rgw_sync_pipe_filter::dump(Formatter *f) const
{
encode_json("prefix", prefix, f);
encode_json("tags", tags, f);
}
void rgw_sync_pipe_filter::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("prefix", prefix, obj);
JSONDecoder::decode_json("tags", tags, obj);
}
void rgw_sync_pipe_acl_translation::dump(Formatter *f) const
{
encode_json("owner", owner, f);
}
void rgw_sync_pipe_acl_translation::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("owner", owner, obj);
}
void rgw_sync_pipe_source_params::dump(Formatter *f) const
{
encode_json("filter", filter, f);
}
void rgw_sync_pipe_source_params::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("filter", filter, obj);
}
void rgw_sync_pipe_dest_params::dump(Formatter *f) const
{
encode_json("acl_translation", acl_translation, f);
encode_json("storage_class", storage_class, f);
}
void rgw_sync_pipe_dest_params::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("acl_translation", acl_translation, obj);
JSONDecoder::decode_json("storage_class", storage_class, obj);
}
void rgw_sync_pipe_params::dump(Formatter *f) const
{
encode_json("source", source, f);
encode_json("dest", dest, f);
encode_json("priority", priority, f);
string s;
switch (mode) {
case MODE_SYSTEM:
s = "system";
break;
default:
s = "user";
}
encode_json("mode", s, f);
encode_json("user", user, f);
}
void rgw_sync_pipe_params::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("source", source, obj);
JSONDecoder::decode_json("dest", dest, obj);
JSONDecoder::decode_json("priority", priority, obj);
string s;
JSONDecoder::decode_json("mode", s, obj);
if (s == "system") {
mode = MODE_SYSTEM;
} else {
mode = MODE_USER;
}
JSONDecoder::decode_json("user", user, obj);
}
void rgw_sync_bucket_entities::dump(Formatter *f) const
{
encode_json("bucket", rgw_sync_bucket_entities::bucket_key(bucket), f);
if (zones) {
encode_json("zones", zones, f);
} else if (all_zones) {
set<string> z = { "*" };
encode_json("zones", z, f);
}
}
void rgw_sync_bucket_entities::decode_json(JSONObj *obj)
{
string s;
JSONDecoder::decode_json("bucket", s, obj);
if (s == "*") {
bucket.reset();
} else {
rgw_bucket b;
int ret = rgw_bucket_parse_bucket_key(nullptr, s, &b, nullptr);
if (ret < 0) {
bucket.reset();
} else {
if (b.tenant == "*") {
b.tenant.clear();
}
if (b.name == "*") {
b.name.clear();
}
if (b.bucket_id == "*") {
b.bucket_id.clear();
}
bucket = b;
}
}
JSONDecoder::decode_json("zones", zones, obj);
if (zones && zones->size() == 1) {
auto iter = zones->begin();
if (*iter == "*") {
zones.reset();
all_zones = true;
}
}
}
void rgw_sync_bucket_pipe::dump(Formatter *f) const
{
encode_json("id", id, f);
encode_json("source", source, f);
encode_json("dest", dest, f);
encode_json("params", params, f);
}
void rgw_sync_bucket_pipe::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("id", id, obj);
JSONDecoder::decode_json("source", source, obj);
JSONDecoder::decode_json("dest", dest, obj);
JSONDecoder::decode_json("params", params, obj);
}
void rgw_sync_bucket_pipes::dump(Formatter *f) const
{
encode_json("id", id, f);
encode_json("source", source, f);
encode_json("dest", dest, f);
encode_json("params", params, f);
}
void rgw_sync_bucket_pipes::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("id", id, obj);
JSONDecoder::decode_json("source", source, obj);
JSONDecoder::decode_json("dest", dest, obj);
JSONDecoder::decode_json("params", params, obj);
}
void rgw_sync_data_flow_group::dump(Formatter *f) const
{
if (!symmetrical.empty()) {
encode_json("symmetrical", symmetrical, f);
}
if (!directional.empty()) {
encode_json("directional", directional, f);
}
}
void rgw_sync_data_flow_group::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("symmetrical", symmetrical, obj);
JSONDecoder::decode_json("directional", directional, obj);
}
void rgw_sync_policy_group::dump(Formatter *f) const
{
encode_json("id", id, f);
encode_json("data_flow", data_flow, f);
encode_json("pipes", pipes, f);
string s;
switch (status) {
case rgw_sync_policy_group::Status::FORBIDDEN:
s = "forbidden";
break;
case rgw_sync_policy_group::Status::ALLOWED:
s = "allowed";
break;
case rgw_sync_policy_group::Status::ENABLED:
s = "enabled";
break;
default:
s = "unknown";
}
encode_json("status", s, f);
}
void rgw_sync_policy_group::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("id", id, obj);
JSONDecoder::decode_json("data_flow", data_flow, obj);
JSONDecoder::decode_json("pipes", pipes, obj);
string s;
JSONDecoder::decode_json("status", s, obj);
set_status(s);
}
void rgw_sync_policy_info::dump(Formatter *f) const
{
Formatter::ArraySection section(*f, "groups");
for (auto& group : groups ) {
encode_json("group", group.second, f);
}
}
void rgw_sync_policy_info::decode_json(JSONObj *obj)
{
vector<rgw_sync_policy_group> groups_vec;
JSONDecoder::decode_json("groups", groups_vec, obj);
for (auto& group : groups_vec) {
groups.emplace(std::make_pair(group.id, std::move(group)));
}
}
| 17,358 | 21.029188 | 159 |
cc
|
null |
ceph-main/src/rgw/rgw_sync_policy.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2018 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#pragma once
#include "rgw_basic_types.h"
#include "rgw_tag.h"
struct rgw_sync_symmetric_group {
std::string id;
std::set<rgw_zone_id> zones;
rgw_sync_symmetric_group() {}
rgw_sync_symmetric_group(const std::string& _id,
const std::set<rgw_zone_id> _zones) : id(_id), zones(_zones) {}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(id, bl);
encode(zones, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(id, bl);
decode(zones, bl);
DECODE_FINISH(bl);
}
void dump(ceph::Formatter *f) const;
void decode_json(JSONObj *obj);
};
WRITE_CLASS_ENCODER(rgw_sync_symmetric_group)
struct rgw_sync_directional_rule {
rgw_zone_id source_zone;
rgw_zone_id dest_zone;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(source_zone, bl);
encode(dest_zone, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(source_zone, bl);
decode(dest_zone, bl);
DECODE_FINISH(bl);
}
void dump(ceph::Formatter *f) const;
void decode_json(JSONObj *obj);
};
WRITE_CLASS_ENCODER(rgw_sync_directional_rule)
struct rgw_sync_bucket_entity {
std::optional<rgw_zone_id> zone; /* define specific zones */
std::optional<rgw_bucket> bucket; /* define specific bucket */
static bool match_str(const std::string& s1, const std::string& s2) { /* empty std::string is wildcard */
return (s1.empty() ||
s2.empty() ||
s1 == s2);
}
bool all_zones{false};
rgw_sync_bucket_entity() {}
rgw_sync_bucket_entity(const rgw_zone_id& _zone,
std::optional<rgw_bucket> _bucket) : zone(_zone),
bucket(_bucket.value_or(rgw_bucket())) {}
bool specific() const {
return zone && bucket;
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(all_zones, bl);
encode(zone, bl);
encode(bucket, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(all_zones, bl);
decode(zone, bl);
decode(bucket, bl);
DECODE_FINISH(bl);
}
void dump(ceph::Formatter *f) const;
void decode_json(JSONObj *obj);
rgw_bucket get_bucket() const {
return bucket.value_or(rgw_bucket());
}
std::string bucket_key() const;
bool match_zone(const rgw_zone_id& z) const {
if (all_zones) {
return true;
}
if (!zone) {
return false;
}
return (*zone == z);
}
void apply_zone(const rgw_zone_id& z) {
all_zones = false;
zone = z;
}
static bool match_bucket_id(const std::string& bid1, const std::string& bid2) {
return (bid1.empty() || bid2.empty() || (bid1 == bid2));
}
bool match_bucket(std::optional<rgw_bucket> b) const {
if (!b) {
return true;
}
if (!bucket) {
return true;
}
return (match_str(bucket->tenant, b->tenant) &&
match_str(bucket->name, b->name) &&
match_bucket_id(bucket->bucket_id, b->bucket_id));
}
bool match(const rgw_sync_bucket_entity& entity) const {
if (!entity.zone) {
return match_bucket(entity.bucket);
}
return (match_zone(*entity.zone) && match_bucket(entity.bucket));
}
const bool operator<(const rgw_sync_bucket_entity& e) const {
if (all_zones && !e.all_zones) {
return false;
}
if (!all_zones && e.all_zones) {
return true;
}
if (zone < e.zone) {
return true;
}
if (e.zone < zone) {
return false;
}
return (bucket < e.bucket);
}
void apply_bucket(std::optional<rgw_bucket> _b);
};
WRITE_CLASS_ENCODER(rgw_sync_bucket_entity)
struct rgw_sync_pipe_filter_tag {
std::string key;
std::string value;
rgw_sync_pipe_filter_tag() {}
rgw_sync_pipe_filter_tag(const std::string& s) {
from_str(s);
}
rgw_sync_pipe_filter_tag(const std::string& _key,
const std::string& _value) : key(_key),
value(_value) {}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(key, bl);
encode(value, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(key, bl);
decode(value, bl);
DECODE_FINISH(bl);
}
void dump(ceph::Formatter *f) const;
void decode_json(JSONObj *obj);
bool from_str(const std::string& s);
bool operator<(const rgw_sync_pipe_filter_tag& t) const {
if (key < t.key) {
return true;
}
if (t.key < key) {
return false;
}
return (value < t.value);
}
bool operator==(const std::string& s) const;
};
WRITE_CLASS_ENCODER(rgw_sync_pipe_filter_tag)
struct rgw_sync_pipe_filter {
std::optional<std::string> prefix;
std::set<rgw_sync_pipe_filter_tag> tags;
void set_prefix(std::optional<std::string> opt_prefix,
bool prefix_rm);
void set_tags(std::list<std::string>& tags_add,
std::list<std::string>& tags_rm);
void encode(bufferlist& bl) const;
void decode(bufferlist::const_iterator& bl);
void dump(ceph::Formatter *f) const;
void decode_json(JSONObj *obj);
bool is_subset_of(const rgw_sync_pipe_filter& f) const;
bool has_tags() const;
bool check_tag(const std::string& s) const;
bool check_tag(const std::string& k, const std::string& v) const;
bool check_tags(const std::vector<std::string>& tags) const;
bool check_tags(const RGWObjTags::tag_map_t& tags) const;
};
WRITE_CLASS_ENCODER(rgw_sync_pipe_filter)
struct rgw_sync_pipe_acl_translation {
rgw_user owner;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(owner, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(owner, bl);
DECODE_FINISH(bl);
}
void dump(ceph::Formatter *f) const;
void decode_json(JSONObj *obj);
bool operator==(const rgw_sync_pipe_acl_translation& aclt) const {
return (owner == aclt.owner);
}
};
WRITE_CLASS_ENCODER(rgw_sync_pipe_acl_translation)
struct rgw_sync_pipe_source_params {
rgw_sync_pipe_filter filter;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(filter, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(filter, bl);
DECODE_FINISH(bl);
}
void dump(ceph::Formatter *f) const;
void decode_json(JSONObj *obj);
};
WRITE_CLASS_ENCODER(rgw_sync_pipe_source_params)
struct rgw_sync_pipe_dest_params {
std::optional<rgw_sync_pipe_acl_translation> acl_translation;
std::optional<std::string> storage_class;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(acl_translation, bl);
encode(storage_class, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(acl_translation, bl);
decode(storage_class, bl);
DECODE_FINISH(bl);
}
void set_storage_class(const std::string& sc) {
storage_class = sc;
}
void set_owner(const rgw_user& owner) {
if (owner.empty()){
acl_translation.reset();
} else {
acl_translation.emplace();
acl_translation->owner = owner;
}
}
void dump(ceph::Formatter *f) const;
void decode_json(JSONObj *obj);
bool operator==(const rgw_sync_pipe_dest_params& rhs) const {
return (acl_translation == rhs.acl_translation &&
storage_class == rhs.storage_class);
}
};
WRITE_CLASS_ENCODER(rgw_sync_pipe_dest_params)
struct rgw_sync_pipe_params {
rgw_sync_pipe_source_params source;
rgw_sync_pipe_dest_params dest;
enum Mode {
MODE_SYSTEM = 0,
MODE_USER = 1,
} mode{MODE_SYSTEM};
int32_t priority{0};
rgw_user user;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(source, bl);
encode(dest, bl);
encode(priority, bl);
encode((uint8_t)mode, bl);
encode(user, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(source, bl);
decode(dest, bl);
decode(priority, bl);
uint8_t m;
decode(m, bl);
mode = (Mode)m;
decode(user, bl);
DECODE_FINISH(bl);
}
void dump(ceph::Formatter *f) const;
void decode_json(JSONObj *obj);
};
WRITE_CLASS_ENCODER(rgw_sync_pipe_params)
struct rgw_sync_bucket_pipe {
std::string id;
rgw_sync_bucket_entity source;
rgw_sync_bucket_entity dest;
rgw_sync_pipe_params params;
bool specific() const {
return source.specific() && dest.specific();
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(id, bl);
encode(source, bl);
encode(dest, bl);
encode(params, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(id, bl);
decode(source, bl);
decode(dest, bl);
decode(params, bl);
DECODE_FINISH(bl);
}
const bool operator<(const rgw_sync_bucket_pipe& p) const {
if (id < p.id) {
return true;
}
if (id >p.id) {
return false;
}
if (source < p.source) {
return true;
}
if (p.source < source) {
return false;
}
return (dest < p.dest);
}
void dump(ceph::Formatter *f) const;
void decode_json(JSONObj *obj);
};
WRITE_CLASS_ENCODER(rgw_sync_bucket_pipe)
struct rgw_sync_bucket_entities {
std::optional<rgw_bucket> bucket; /* define specific bucket */
std::optional<std::set<rgw_zone_id> > zones; /* define specific zones, if not set then all zones */
bool all_zones{false};
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(bucket, bl);
encode(zones, bl);
encode(all_zones, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(bucket, bl);
decode(zones, bl);
decode(all_zones, bl);
DECODE_FINISH(bl);
}
void dump(ceph::Formatter *f) const;
void decode_json(JSONObj *obj);
bool match_bucket(std::optional<rgw_bucket> b) const {
if (!b) {
return true;
}
if (!bucket) {
return true;
}
return (rgw_sync_bucket_entity::match_str(bucket->tenant, b->tenant) &&
rgw_sync_bucket_entity::match_str(bucket->name, b->name) &&
rgw_sync_bucket_entity::match_str(bucket->bucket_id, b->bucket_id));
}
void add_zones(const std::vector<rgw_zone_id>& new_zones);
void remove_zones(const std::vector<rgw_zone_id>& rm_zones);
void set_bucket(std::optional<std::string> tenant,
std::optional<std::string> bucket_name,
std::optional<std::string> bucket_id);
void remove_bucket(std::optional<std::string> tenant,
std::optional<std::string> bucket_name,
std::optional<std::string> bucket_id);
bool match_zone(const rgw_zone_id& zone) const {
if (!zones) {
if (all_zones) {
return true;
}
return false;
}
return (zones->find(zone) != zones->end());
}
std::vector<rgw_sync_bucket_entity> expand() const;
rgw_bucket get_bucket() const {
return bucket.value_or(rgw_bucket());
}
static std::string bucket_key(std::optional<rgw_bucket> b);
void set_all_zones(bool state) {
all_zones = state;
if (all_zones) {
zones.reset();
}
}
};
WRITE_CLASS_ENCODER(rgw_sync_bucket_entities)
struct rgw_sync_bucket_pipes {
std::string id;
rgw_sync_bucket_entities source;
rgw_sync_bucket_entities dest;
rgw_sync_pipe_params params;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(id, bl);
encode(source, bl);
encode(dest, bl);
encode(params, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(id, bl);
decode(source, bl);
decode(dest, bl);
decode(params, bl);
DECODE_FINISH(bl);
}
bool match_source(const rgw_zone_id& zone, std::optional<rgw_bucket> b) const {
return (source.match_zone(zone) && source.match_bucket(b));
}
bool match_dest(const rgw_zone_id& zone, std::optional<rgw_bucket> b) const {
return (dest.match_zone(zone) && dest.match_bucket(b));
}
bool contains_zone_bucket(const rgw_zone_id& zone, std::optional<rgw_bucket> b) const {
return (match_source(zone, b) || match_dest(zone, b));
}
void dump(ceph::Formatter *f) const;
void decode_json(JSONObj *obj);
std::vector<rgw_sync_bucket_pipe> expand() const;
void get_potential_related_buckets(const rgw_bucket& bucket,
std::set<rgw_bucket> *sources,
std::set<rgw_bucket> *dests) const;
};
WRITE_CLASS_ENCODER(rgw_sync_bucket_pipes)
std::ostream& operator<<(std::ostream& os, const rgw_sync_bucket_entity& e);
std::ostream& operator<<(std::ostream& os, const rgw_sync_bucket_pipe& pipe);
std::ostream& operator<<(std::ostream& os, const rgw_sync_bucket_entities& e);
std::ostream& operator<<(std::ostream& os, const rgw_sync_bucket_pipes& pipe);
/*
* define data flow between zones. Symmetrical: zones sync from each other.
* Directional: one zone fetches data from another.
*/
struct rgw_sync_data_flow_group {
std::vector<rgw_sync_symmetric_group> symmetrical;
std::vector<rgw_sync_directional_rule> directional;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(symmetrical, bl);
encode(directional, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(symmetrical, bl);
decode(directional, bl);
DECODE_FINISH(bl);
}
void dump(ceph::Formatter *f) const;
void decode_json(JSONObj *obj);
bool empty() const {
return (symmetrical.empty() && directional.empty());
}
bool find_or_create_symmetrical(const std::string& flow_id, rgw_sync_symmetric_group **flow_group);
void remove_symmetrical(const std::string& flow_id, std::optional<std::vector<rgw_zone_id> > zones);
bool find_or_create_directional(const rgw_zone_id& source_zone, const rgw_zone_id& dest_zone, rgw_sync_directional_rule **flow_group);
void remove_directional(const rgw_zone_id& source_zone, const rgw_zone_id& dest_zone);
void init_default(const std::set<rgw_zone_id>& zones);
};
WRITE_CLASS_ENCODER(rgw_sync_data_flow_group)
struct rgw_sync_policy_group {
std::string id;
rgw_sync_data_flow_group data_flow; /* override data flow, howver, will not be able to
add new flows that don't exist at higher level */
std::vector<rgw_sync_bucket_pipes> pipes; /* if not defined then applies to all
buckets (DR sync) */
enum Status {
UNKNOWN = 0, /* ? */
FORBIDDEN = 1, /* sync not allowed */
ALLOWED = 2, /* sync allowed */
ENABLED = 3, /* sync should happen */
} status;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(id, bl);
encode(data_flow, bl);
encode(pipes, bl);
encode((uint32_t)status, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(id, bl);
decode(data_flow, bl);
decode(pipes, bl);
uint32_t s;
decode(s, bl);
status = (Status)s;
DECODE_FINISH(bl);
}
void dump(ceph::Formatter *f) const;
void decode_json(JSONObj *obj);
bool set_status(const std::string& s) {
if (s == "forbidden") {
status = rgw_sync_policy_group::Status::FORBIDDEN;
} else if (s == "allowed") {
status = rgw_sync_policy_group::Status::ALLOWED;
} else if (s == "enabled") {
status = rgw_sync_policy_group::Status::ENABLED;
} else {
status = rgw_sync_policy_group::Status::UNKNOWN;
return false;
}
return true;
}
bool find_pipe(const std::string& pipe_id, bool create, rgw_sync_bucket_pipes **pipe);
void remove_pipe(const std::string& pipe_id);
void get_potential_related_buckets(const rgw_bucket& bucket,
std::set<rgw_bucket> *sources,
std::set<rgw_bucket> *dests) const;
};
WRITE_CLASS_ENCODER(rgw_sync_policy_group)
struct rgw_sync_policy_info {
std::map<std::string, rgw_sync_policy_group> groups;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(groups, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(groups, bl);
DECODE_FINISH(bl);
}
void dump(ceph::Formatter *f) const;
void decode_json(JSONObj *obj);
bool empty() const {
return groups.empty();
}
void get_potential_related_buckets(const rgw_bucket& bucket,
std::set<rgw_bucket> *sources,
std::set<rgw_bucket> *dests) const;
};
WRITE_CLASS_ENCODER(rgw_sync_policy_info)
| 17,549 | 24.695461 | 136 |
h
|
null |
ceph-main/src/rgw/rgw_tag.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#include <map>
#include <string>
#include <common/errno.h>
#include <boost/algorithm/string.hpp>
#include "rgw_tag.h"
#include "rgw_common.h"
using namespace std;
void RGWObjTags::add_tag(const string& key, const string& val){
tag_map.emplace(std::make_pair(key,val));
}
void RGWObjTags::emplace_tag(std::string&& key, std::string&& val){
tag_map.emplace(std::move(key), std::move(val));
}
int RGWObjTags::check_and_add_tag(const string&key, const string& val){
if (tag_map.size() == max_obj_tags ||
key.size() > max_tag_key_size ||
val.size() > max_tag_val_size ||
key.size() == 0){
return -ERR_INVALID_TAG;
}
add_tag(key,val);
return 0;
}
int RGWObjTags::set_from_string(const string& input){
if (input.empty()) {
return 0;
}
int ret=0;
vector <string> kvs;
boost::split(kvs, input, boost::is_any_of("&"));
for (const auto& kv: kvs){
auto p = kv.find("=");
string key,val;
if (p != string::npos) {
ret = check_and_add_tag(url_decode(kv.substr(0,p)),
url_decode(kv.substr(p+1)));
} else {
ret = check_and_add_tag(url_decode(kv));
}
if (ret < 0)
return ret;
}
return ret;
}
void RGWObjTags::dump(Formatter *f) const
{
f->open_object_section("tagset");
for (auto& tag: tag_map){
f->dump_string(tag.first.c_str(), tag.second);
}
f->close_section();
}
| 1,505 | 21.147059 | 71 |
cc
|
null |
ceph-main/src/rgw/rgw_tag.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#pragma once
#include <string>
#include <include/types.h>
#include <map>
class RGWObjTags
{
public:
using tag_map_t = std::multimap <std::string, std::string>;
protected:
tag_map_t tag_map;
uint32_t max_obj_tags{10};
static constexpr uint32_t max_tag_key_size{128};
static constexpr uint32_t max_tag_val_size{256};
public:
RGWObjTags() = default;
RGWObjTags(uint32_t max_obj_tags):max_obj_tags(max_obj_tags) {}
void encode(bufferlist& bl) const {
ENCODE_START(1,1,bl);
encode(tag_map, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(1, 1, 1, bl);
decode(tag_map,bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void add_tag(const std::string& key, const std::string& val="");
void emplace_tag(std::string&& key, std::string&& val);
int check_and_add_tag(const std::string& key, const std::string& val="");
size_t count() const {return tag_map.size();}
int set_from_string(const std::string& input);
void clear() { tag_map.clear(); }
bool empty() const noexcept { return tag_map.empty(); }
const tag_map_t& get_tags() const {return tag_map;}
tag_map_t& get_tags() {return tag_map;}
};
WRITE_CLASS_ENCODER(RGWObjTags)
| 1,360 | 26.22 | 75 |
h
|
null |
ceph-main/src/rgw/rgw_tag_s3.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#include <map>
#include <string>
#include <iostream>
#include "include/types.h"
#include "rgw_tag_s3.h"
using namespace std;
void RGWObjTagEntry_S3::decode_xml(XMLObj *obj) {
RGWXMLDecoder::decode_xml("Key", key, obj, true);
RGWXMLDecoder::decode_xml("Value", val, obj, true);
}
void RGWObjTagEntry_S3::dump_xml(Formatter *f) const {
encode_xml("Key", key, f);
encode_xml("Value", val, f);
if (key.empty()) {
throw RGWXMLDecoder::err("empty key");
}
if (val.empty()) {
throw RGWXMLDecoder::err("empty val");
}
}
void RGWObjTagSet_S3::decode_xml(XMLObj *obj) {
vector<RGWObjTagEntry_S3> entries;
bool mandatory{false};
RGWXMLDecoder::decode_xml("Tag", entries, obj, mandatory);
for (auto& entry : entries) {
const std::string& key = entry.get_key();
const std::string& val = entry.get_val();
add_tag(key,val);
}
}
int RGWObjTagSet_S3::rebuild(RGWObjTags& dest) {
int ret;
for (const auto &it : tag_map){
ret = dest.check_and_add_tag(it.first, it.second);
if (ret < 0)
return ret;
}
return 0;
}
void RGWObjTagging_S3::decode_xml(XMLObj *obj) {
RGWXMLDecoder::decode_xml("TagSet", tagset, obj, true);
}
void RGWObjTagSet_S3::dump_xml(Formatter *f) const {
for (const auto& tag : tag_map){
Formatter::ObjectSection os(*f, "Tag");
encode_xml("Key", tag.first, f);
encode_xml("Value", tag.second, f);
}
}
| 1,505 | 21.477612 | 70 |
cc
|
null |
ceph-main/src/rgw/rgw_tag_s3.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#pragma once
#include <map>
#include <string>
#include <iostream>
#include <include/types.h>
#include <common/Formatter.h>
#include <expat.h>
#include "rgw_tag.h"
#include "rgw_xml.h"
class RGWObjTagEntry_S3
{
std::string key;
std::string val;
public:
RGWObjTagEntry_S3() {}
RGWObjTagEntry_S3(const std::string &k, const std::string &v):key(k),val(v) {};
~RGWObjTagEntry_S3() {}
const std::string& get_key () const { return key; }
const std::string& get_val () const { return val; }
void dump_xml(Formatter *f) const;
void decode_xml(XMLObj *obj);
};
class RGWObjTagSet_S3: public RGWObjTags
{
public:
int rebuild(RGWObjTags& dest);
void dump_xml(Formatter *f) const;
void decode_xml(XMLObj *obj);
};
class RGWObjTagging_S3
{
RGWObjTagSet_S3 tagset;
public:
void decode_xml(XMLObj *obj);
int rebuild(RGWObjTags& dest) {
return tagset.rebuild(dest);
}
};
| 1,004 | 19.1 | 81 |
h
|
null |
ceph-main/src/rgw/rgw_tar.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#pragma once
#include <algorithm>
#include <array>
#include <cstring>
#include <string_view>
#include <tuple>
#include <utility>
#include <boost/optional.hpp>
#include <boost/range/adaptor/reversed.hpp>
namespace rgw {
namespace tar {
static constexpr size_t BLOCK_SIZE = 512;
static inline std::pair<class StatusIndicator,
boost::optional<class HeaderView>>
interpret_block(const StatusIndicator& status, ceph::bufferlist& bl);
class StatusIndicator {
friend std::pair<class StatusIndicator,
boost::optional<class HeaderView>>
interpret_block(const StatusIndicator& status, ceph::bufferlist& bl);
bool is_empty;
bool is_eof;
StatusIndicator()
: is_empty(false),
is_eof(false) {
}
StatusIndicator(const StatusIndicator& prev_status,
const bool is_empty)
: is_empty(is_empty),
is_eof(is_empty && prev_status.empty()) {
}
public:
bool empty() const {
return is_empty;
}
bool eof() const {
return is_eof;
}
static StatusIndicator create() {
return StatusIndicator();
}
} /* class StatusIndicator */;
enum class FileType : char {
UNKNOWN = '\0',
/* The tar format uses ASCII encoding. */
NORMAL_FILE = '0',
DIRECTORY = '5'
}; /* enum class FileType */
class HeaderView {
protected:
/* Everything is char here (ASCII encoding), so we don't need to worry about
* the struct padding. */
const struct header_t {
char filename[100];
char __filemode[8];
char __owner_id[8];
char __group_id[8];
char filesize[12];
char lastmod[12];
char checksum[8];
char filetype;
char __padding[355];
} *header;
static_assert(sizeof(*header) == BLOCK_SIZE,
"The TAR header must be exactly BLOCK_SIZE length");
/* The label is far more important from what the code really does. */
static size_t pos2len(const size_t pos) {
return pos + 1;
}
public:
explicit HeaderView(const char (&header)[BLOCK_SIZE])
: header(reinterpret_cast<const header_t*>(header)) {
}
FileType get_filetype() const {
switch (header->filetype) {
case static_cast<char>(FileType::NORMAL_FILE):
return FileType::NORMAL_FILE;
case static_cast<char>(FileType::DIRECTORY):
return FileType::DIRECTORY;
default:
return FileType::UNKNOWN;
}
}
std::string_view get_filename() const {
return std::string_view(header->filename,
std::min(sizeof(header->filename),
strlen(header->filename)));
}
size_t get_filesize() const {
/* The string_ref is pretty suitable here because tar encodes its
* metadata in ASCII. */
const std::string_view raw(header->filesize, sizeof(header->filesize));
/* We need to find where the padding ends. */
const auto pad_ends_at = std::min(raw.find_last_not_of('\0'),
raw.find_last_not_of(' '));
const auto trimmed = raw.substr(0,
pad_ends_at == std::string_view::npos ? std::string_view::npos
: pos2len(pad_ends_at));
size_t sum = 0, mul = 1;
for (const char c : boost::adaptors::reverse(trimmed)) {
sum += (c - '0') * mul;
mul *= 8;
}
return sum;
}
}; /* class Header */
static inline std::pair<StatusIndicator,
boost::optional<HeaderView>>
interpret_block(const StatusIndicator& status, ceph::bufferlist& bl) {
static constexpr std::array<char, BLOCK_SIZE> zero_block = {0, };
const char (&block)[BLOCK_SIZE] = \
reinterpret_cast<const char (&)[BLOCK_SIZE]>(*bl.c_str());
if (std::memcmp(zero_block.data(), block, BLOCK_SIZE) == 0) {
return std::make_pair(StatusIndicator(status, true), boost::none);
} else {
return std::make_pair(StatusIndicator(status, false), HeaderView(block));
}
}
} /* namespace tar */
} /* namespace rgw */
| 4,059 | 25.363636 | 78 |
h
|
null |
ceph-main/src/rgw/rgw_token.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2016 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <errno.h>
#include <iostream>
#include <sstream>
#include <string>
#include "common/config.h"
#include "common/ceph_argparse.h"
#include "common/debug.h"
#include "global/global_init.h"
#include "include/ceph_assert.h"
#include "include/str_list.h"
#include "rgw_token.h"
#include "rgw_b64.h"
#define dout_subsys ceph_subsys_rgw
namespace {
using namespace rgw;
using std::get;
using std::string;
RGWToken::token_type type{RGWToken::TOKEN_NONE};
string access_key{""};
string secret_key{""};
Formatter* token_formatter{nullptr};
bool verbose {false};
bool do_encode {false};
bool do_decode {false};
}
using namespace std;
void usage()
{
cout << "usage: radosgw-token --encode --ttype=<token type> [options...]" << std::endl;
cout << "\t(maybe exporting RGW_ACCESS_KEY_ID and RGW_SECRET_ACCESS_KEY)"
<< std::endl;
cout << "\t <token type> := ad | ldap" << std::endl;
cout << "\n";
generic_client_usage();
}
int main(int argc, char **argv)
{
auto args = argv_to_vec(argc, argv);
std::string val;
if (args.empty()) {
cerr << argv[0] << ": -h or --help for usage" << std::endl;
exit(1);
}
if (ceph_argparse_need_usage(args)) {
usage();
exit(0);
}
auto cct = global_init(nullptr, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY, 0);
common_init_finish(g_ceph_context);
char *v{nullptr};
v = getenv("RGW_ACCESS_KEY_ID");
if (v) {
access_key = v;
}
v = getenv("RGW_SECRET_ACCESS_KEY");
if (v) {
secret_key = v;
}
for (auto arg_iter = args.begin(); arg_iter != args.end();) {
if (ceph_argparse_witharg(args, arg_iter, &val, "--access",
(char*) nullptr)) {
access_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--secret",
(char*) nullptr)) {
secret_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--ttype",
(char*) nullptr)) {
for (const auto& ttype : {"ad", "ldap"}) {
if (boost::iequals(val, ttype)) {
type = RGWToken::to_type(val);
break;
}
}
} else if (ceph_argparse_flag(args, arg_iter, "--encode",
(char*) nullptr)) {
do_encode = true;
} else if (ceph_argparse_flag(args, arg_iter, "--decode",
(char*) nullptr)) {
do_decode = true;
} else if (ceph_argparse_flag(args, arg_iter, "--verbose",
(char*) nullptr)) {
verbose = true;
} else {
++arg_iter;
}
}
if ((! do_encode) ||
(type == RGWToken::TOKEN_NONE)) {
return -EINVAL;
}
token_formatter = new JSONFormatter(true /* pretty */);
RGWToken token(type, access_key, secret_key);
if (do_encode) {
token.encode_json(token_formatter);
std::ostringstream os;
token_formatter->flush(os);
string token_str = os.str();
if (verbose) {
std::cout << "expanded token: " << token_str << std::endl;
if (do_decode) {
RGWToken token2(token_str);
std::cout << "decoded expanded token: " << token2 << std::endl;
}
}
std::cout << to_base64(token_str) << std::endl;
}
return 0;
}
| 3,512 | 23.227586 | 89 |
cc
|
null |
ceph-main/src/rgw/rgw_token.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2016 Red Hat, Inc
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#pragma once
#include <stdint.h>
#include <boost/algorithm/string.hpp>
#include <sstream>
#include "common/ceph_json.h"
#include "common/Formatter.h"
#include "rgw/rgw_b64.h"
namespace rgw {
using std::string;
class RGWToken {
public:
static constexpr auto type_name = "RGW_TOKEN";
enum token_type : uint32_t {
TOKEN_NONE,
TOKEN_AD,
TOKEN_KEYSTONE,
TOKEN_LDAP,
};
static enum token_type to_type(const string& s) {
if (boost::iequals(s, "ad"))
return TOKEN_AD;
if (boost::iequals(s, "ldap"))
return TOKEN_LDAP;
if (boost::iequals(s, "keystone"))
return TOKEN_KEYSTONE;
return TOKEN_NONE;
}
static const char* from_type(enum token_type type) {
switch (type) {
case TOKEN_AD:
return "ad";
case TOKEN_LDAP:
return "ldap";
case TOKEN_KEYSTONE:
return "keystone";
default:
return "none";
};
}
token_type type;
string id;
string key;
virtual uint32_t version() const { return 1; };
bool valid() const{
return ((type != TOKEN_NONE) &&
(! id.empty()) &&
(! key.empty()));
}
RGWToken()
: type(TOKEN_NONE) {};
RGWToken(enum token_type _type, const std::string& _id,
const std::string& _key)
: type(_type), id(_id), key(_key) {};
explicit RGWToken(const string& json) {
JSONParser p;
p.parse(json.c_str(), json.length());
JSONDecoder::decode_json(RGWToken::type_name, *this, &p);
}
RGWToken& operator=(const std::string& json) {
JSONParser p;
p.parse(json.c_str(), json.length());
JSONDecoder::decode_json(RGWToken::type_name, *this, &p);
return *this;
}
void encode(bufferlist& bl) const {
uint32_t ver = version();
string typestr{from_type(type)};
ENCODE_START(1, 1, bl);
encode(type_name, bl);
encode(ver, bl);
encode(typestr, bl);
encode(id, bl);
encode(key, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
string name;
string typestr;
uint32_t version;
DECODE_START(1, bl);
decode(name, bl);
decode(version, bl);
decode(typestr, bl);
type = to_type(typestr);
decode(id, bl);
decode(key, bl);
DECODE_FINISH(bl);
}
void dump(Formatter* f) const {
::encode_json("version", uint32_t(version()), f);
::encode_json("type", from_type(type), f);
::encode_json("id", id, f);
::encode_json("key", key, f);
}
void encode_json(Formatter* f) {
RGWToken& token = *this;
f->open_object_section(type_name);
::encode_json(type_name, token, f);
f->close_section();
}
void decode_json(JSONObj* obj) {
uint32_t version;
string type_name;
string typestr;
JSONDecoder::decode_json("version", version, obj);
JSONDecoder::decode_json("type", typestr, obj);
type = to_type(typestr);
JSONDecoder::decode_json("id", id, obj);
JSONDecoder::decode_json("key", key, obj);
}
std::string encode_json_base64(Formatter* f) {
encode_json(f);
std::ostringstream os;
f->flush(os);
return to_base64(std::move(os.str()));
}
friend inline std::ostream& operator<<(std::ostream& os, const RGWToken& token);
virtual ~RGWToken() {};
};
WRITE_CLASS_ENCODER(RGWToken)
inline std::ostream& operator<<(std::ostream& os, const RGWToken& token)
{
os << "<<RGWToken"
<< " type=" << RGWToken::from_type(token.type)
<< " id=" << token.id
<< " key=" << token.key
<< ">>";
return os;
}
} /* namespace rgw */
| 4,088 | 22.912281 | 84 |
h
|
null |
ceph-main/src/rgw/rgw_tools.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#include <errno.h>
#include "common/errno.h"
#include "rgw_tools.h"
#define dout_subsys ceph_subsys_rgw
#define dout_context g_ceph_context
#define READ_CHUNK_LEN (512 * 1024)
using namespace std;
static std::map<std::string, std::string>* ext_mime_map;
void parse_mime_map_line(const char *start, const char *end)
{
char line[end - start + 1];
strncpy(line, start, end - start);
line[end - start] = '\0';
char *l = line;
#define DELIMS " \t\n\r"
while (isspace(*l))
l++;
char *mime = strsep(&l, DELIMS);
if (!mime)
return;
char *ext;
do {
ext = strsep(&l, DELIMS);
if (ext && *ext) {
(*ext_mime_map)[ext] = mime;
}
} while (ext);
}
void parse_mime_map(const char *buf)
{
const char *start = buf, *end = buf;
while (*end) {
while (*end && *end != '\n') {
end++;
}
parse_mime_map_line(start, end);
end++;
start = end;
}
}
static int ext_mime_map_init(const DoutPrefixProvider *dpp, CephContext *cct, const char *ext_map)
{
int fd = open(ext_map, O_RDONLY);
char *buf = NULL;
int ret;
if (fd < 0) {
ret = -errno;
ldpp_dout(dpp, 0) << __func__ << " failed to open file=" << ext_map
<< " : " << cpp_strerror(-ret) << dendl;
return ret;
}
struct stat st;
ret = fstat(fd, &st);
if (ret < 0) {
ret = -errno;
ldpp_dout(dpp, 0) << __func__ << " failed to stat file=" << ext_map
<< " : " << cpp_strerror(-ret) << dendl;
goto done;
}
buf = (char *)malloc(st.st_size + 1);
if (!buf) {
ret = -ENOMEM;
ldpp_dout(dpp, 0) << __func__ << " failed to allocate buf" << dendl;
goto done;
}
ret = safe_read(fd, buf, st.st_size + 1);
if (ret != st.st_size) {
// huh? file size has changed?
ldpp_dout(dpp, 0) << __func__ << " raced! will retry.." << dendl;
free(buf);
close(fd);
return ext_mime_map_init(dpp, cct, ext_map);
}
buf[st.st_size] = '\0';
parse_mime_map(buf);
ret = 0;
done:
free(buf);
close(fd);
return ret;
}
const char *rgw_find_mime_by_ext(string& ext)
{
map<string, string>::iterator iter = ext_mime_map->find(ext);
if (iter == ext_mime_map->end())
return NULL;
return iter->second.c_str();
}
int rgw_tools_init(const DoutPrefixProvider *dpp, CephContext *cct)
{
ext_mime_map = new std::map<std::string, std::string>;
ext_mime_map_init(dpp, cct, cct->_conf->rgw_mime_types_file.c_str());
// ignore errors; missing mime.types is not fatal
return 0;
}
void rgw_tools_cleanup()
{
delete ext_mime_map;
ext_mime_map = nullptr;
}
| 2,678 | 20.432 | 98 |
cc
|
null |
ceph-main/src/rgw/rgw_torrent.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#include "rgw_torrent.h"
#include <ctime>
#include <fmt/format.h>
#include "common/split.h"
#include "rgw_sal.h"
#define ANNOUNCE "announce"
#define ANNOUNCE_LIST "announce-list"
#define COMMENT "comment"
#define CREATED_BY "created by"
#define CREATION_DATE "creation date"
#define ENCODING "encoding"
#define LENGTH "length"
#define NAME "name"
#define PIECE_LENGTH "piece length"
#define PIECES "pieces"
#define INFO_PIECES "info"
//control characters
void bencode_dict(bufferlist& bl) { bl.append('d'); }
void bencode_list(bufferlist& bl) { bl.append('l'); }
void bencode_end(bufferlist& bl) { bl.append('e'); }
//key len
void bencode_key(std::string_view key, bufferlist& bl)
{
bl.append(fmt::format("{}:", key.size()));
bl.append(key);
}
//single values
void bencode(int value, bufferlist& bl)
{
bl.append(fmt::format("i{}", value));
bencode_end(bl);
}
//single values
void bencode(std::string_view str, bufferlist& bl)
{
bencode_key(str, bl);
}
//dictionary elements
void bencode(std::string_view key, int value, bufferlist& bl)
{
bencode_key(key, bl);
bencode(value, bl);
}
//dictionary elements
void bencode(std::string_view key, std::string_view value, bufferlist& bl)
{
bencode_key(key, bl);
bencode(value, bl);
}
int rgw_read_torrent_file(const DoutPrefixProvider* dpp,
rgw::sal::Object* object,
ceph::bufferlist &bl,
optional_yield y)
{
bufferlist infobl;
int r = object->get_torrent_info(dpp, y, infobl);
if (r < 0) {
ldpp_dout(dpp, 0) << "ERROR: read_torrent_info failed: " << r << dendl;
return r;
}
// add other fields from config
auto& conf = dpp->get_cct()->_conf;
bencode_dict(bl);
auto trackers = ceph::split(conf->rgw_torrent_tracker, ",");
if (auto i = trackers.begin(); i != trackers.end()) {
bencode_key(ANNOUNCE, bl);
bencode_key(*i, bl);
bencode_key(ANNOUNCE_LIST, bl);
bencode_list(bl);
for (; i != trackers.end(); ++i) {
bencode_list(bl);
bencode_key(*i, bl);
bencode_end(bl);
}
bencode_end(bl);
}
std::string_view comment = conf->rgw_torrent_comment;
if (!comment.empty()) {
bencode(COMMENT, comment, bl);
}
std::string_view create_by = conf->rgw_torrent_createby;
if (!create_by.empty()) {
bencode(CREATED_BY, create_by, bl);
}
std::string_view encoding = conf->rgw_torrent_encoding;
if (!encoding.empty()) {
bencode(ENCODING, encoding, bl);
}
// append the info stored in the object
bl.append(std::move(infobl));
return 0;
}
RGWPutObj_Torrent::RGWPutObj_Torrent(rgw::sal::DataProcessor* next,
size_t max_len, size_t piece_len)
: Pipe(next), max_len(max_len), piece_len(piece_len)
{
}
int RGWPutObj_Torrent::process(bufferlist&& data, uint64_t logical_offset)
{
if (!data.length()) { // done
if (piece_offset) { // hash the remainder
char out[ceph::crypto::SHA1::digest_size];
digest.Final(reinterpret_cast<unsigned char*>(out));
piece_hashes.append(out, sizeof(out));
piece_count++;
}
return Pipe::process(std::move(data), logical_offset);
}
len += data.length();
if (len >= max_len) {
// enforce the maximum object size; stop calculating and buffering hashes
piece_hashes.clear();
piece_offset = 0;
piece_count = 0;
return Pipe::process(std::move(data), logical_offset);
}
auto p = data.begin();
while (!p.end()) {
// feed each buffer segment through sha1
uint32_t want = piece_len - piece_offset;
const char* buf = nullptr;
size_t bytes = p.get_ptr_and_advance(want, &buf);
digest.Update(reinterpret_cast<const unsigned char*>(buf), bytes);
piece_offset += bytes;
// record the hash digest at each piece boundary
if (bytes == want) {
char out[ceph::crypto::SHA1::digest_size];
digest.Final(reinterpret_cast<unsigned char*>(out));
digest.Restart();
piece_hashes.append(out, sizeof(out));
piece_count++;
piece_offset = 0;
}
}
return Pipe::process(std::move(data), logical_offset);
}
bufferlist RGWPutObj_Torrent::bencode_torrent(std::string_view filename) const
{
bufferlist bl;
if (len >= max_len) {
return bl;
}
// Only encode create_date and sha1 info. Other fields will be added during
// GetObjectTorrent by rgw_read_torrent_file()
// issue tracked here: https://tracker.ceph.com/issues/61160
// coverity[store_truncates_time_t:SUPPRESS]
bencode(CREATION_DATE, std::time(nullptr), bl);
bencode_key(INFO_PIECES, bl);
bencode_dict(bl);
bencode(LENGTH, len, bl);
bencode(NAME, filename, bl);
bencode(PIECE_LENGTH, piece_len, bl);
bencode_key(PIECES, bl);
bl.append(std::to_string(piece_count));
bl.append(':');
bl.append(piece_hashes);
bencode_end(bl);
return bl;
}
| 5,066 | 25.668421 | 78 |
cc
|
null |
ceph-main/src/rgw/rgw_torrent.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#pragma once
#include "common/ceph_crypto.h"
#include "common/dout.h"
#include "common/async/yield_context.h"
#include "rgw_putobj.h"
#include "rgw_sal_fwd.h"
//control characters
void bencode_dict(bufferlist& bl);
void bencode_list(bufferlist& bl);
void bencode_end(bufferlist& bl);
//key len
void bencode_key(std::string_view key, bufferlist& bl);
//single values
void bencode(int value, bufferlist& bl);
//single values
void bencode(std::string_view str, bufferlist& bl);
//dictionary elements
void bencode(std::string_view key, int value, bufferlist& bl);
//dictionary elements
void bencode(std::string_view key, std::string_view value, bufferlist& bl);
// read the bencoded torrent file from the given object
int rgw_read_torrent_file(const DoutPrefixProvider* dpp,
rgw::sal::Object* object,
ceph::bufferlist &bl,
optional_yield y);
// PutObj filter that builds a torrent file during upload
class RGWPutObj_Torrent : public rgw::putobj::Pipe {
size_t max_len = 0;
size_t piece_len = 0;
bufferlist piece_hashes;
size_t len = 0;
size_t piece_offset = 0;
uint32_t piece_count = 0;
ceph::crypto::SHA1 digest;
public:
RGWPutObj_Torrent(rgw::sal::DataProcessor* next,
size_t max_len, size_t piece_len);
int process(bufferlist&& data, uint64_t logical_offset) override;
// after processing is complete, return the bencoded torrent file
bufferlist bencode_torrent(std::string_view filename) const;
};
| 1,639 | 26.79661 | 75 |
h
|
null |
ceph-main/src/rgw/rgw_tracer.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include <string>
#include "rgw_tracer.h"
namespace tracing {
namespace rgw {
tracing::Tracer tracer;
} // namespace rgw
} // namespace tracing
| 246 | 16.642857 | 70 |
cc
|
null |
ceph-main/src/rgw/rgw_tracer.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#pragma once
#include "common/tracer.h"
#include "rgw_common.h"
namespace tracing {
namespace rgw {
const auto OP = "op";
const auto BUCKET_NAME = "bucket_name";
const auto USER_ID = "user_id";
const auto OBJECT_NAME = "object_name";
const auto RETURN = "return";
const auto UPLOAD_ID = "upload_id";
const auto TYPE = "type";
const auto REQUEST = "request";
const auto MULTIPART = "multipart_upload ";
extern tracing::Tracer tracer;
} // namespace rgw
} // namespace tracing
static inline void extract_span_context(const rgw::sal::Attrs& attr, jspan_context& span_ctx) {
auto trace_iter = attr.find(RGW_ATTR_TRACE);
if (trace_iter != attr.end()) {
try {
auto trace_bl_iter = trace_iter->second.cbegin();
tracing::decode(span_ctx, trace_bl_iter);
} catch (buffer::error& err) {}
}
}
| 912 | 25.085714 | 95 |
h
|
null |
ceph-main/src/rgw/rgw_url.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include <string>
#include <regex>
namespace rgw {
namespace {
const auto USER_GROUP_IDX = 3;
const auto PASSWORD_GROUP_IDX = 4;
const auto HOST_GROUP_IDX = 5;
const std::string schema_re = "([[:alpha:]]+:\\/\\/)";
const std::string user_pass_re = "(([^:\\s]+):([^@\\s]+)@)?";
const std::string host_port_re = "([[:alnum:].:-]+)";
const std::string path_re = "(/[[:print:]]*)?";
}
bool parse_url_authority(const std::string& url, std::string& host, std::string& user, std::string& password) {
const std::string re = schema_re + user_pass_re + host_port_re + path_re;
const std::regex url_regex(re, std::regex::icase);
std::smatch url_match_result;
if (std::regex_match(url, url_match_result, url_regex)) {
host = url_match_result[HOST_GROUP_IDX];
user = url_match_result[USER_GROUP_IDX];
password = url_match_result[PASSWORD_GROUP_IDX];
return true;
}
return false;
}
bool parse_url_userinfo(const std::string& url, std::string& user, std::string& password) {
const std::string re = schema_re + user_pass_re + host_port_re + path_re;
const std::regex url_regex(re);
std::smatch url_match_result;
if (std::regex_match(url, url_match_result, url_regex)) {
user = url_match_result[USER_GROUP_IDX];
password = url_match_result[PASSWORD_GROUP_IDX];
return true;
}
return false;
}
}
| 1,452 | 28.06 | 111 |
cc
|
null |
ceph-main/src/rgw/rgw_url.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#pragma once
#include <string>
namespace rgw {
// parse a URL of the form: http|https|amqp|amqps|kafka://[user:password@]<host>[:port]
bool parse_url_authority(const std::string& url, std::string& host, std::string& user, std::string& password);
bool parse_url_userinfo(const std::string& url, std::string& user, std::string& password);
}
| 440 | 32.923077 | 110 |
h
|
null |
ceph-main/src/rgw/rgw_usage.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#include <string>
#include <map>
#include "rgw_rados.h"
#include "rgw_usage.h"
#include "rgw_formats.h"
#include "rgw_sal.h"
using namespace std;
static void dump_usage_categories_info(Formatter *formatter, const rgw_usage_log_entry& entry, map<string, bool> *categories)
{
formatter->open_array_section("categories");
map<string, rgw_usage_data>::const_iterator uiter;
for (uiter = entry.usage_map.begin(); uiter != entry.usage_map.end(); ++uiter) {
if (categories && !categories->empty() && !categories->count(uiter->first))
continue;
const rgw_usage_data& usage = uiter->second;
formatter->open_object_section("entry");
formatter->dump_string("category", uiter->first);
formatter->dump_unsigned("bytes_sent", usage.bytes_sent);
formatter->dump_unsigned("bytes_received", usage.bytes_received);
formatter->dump_unsigned("ops", usage.ops);
formatter->dump_unsigned("successful_ops", usage.successful_ops);
formatter->close_section(); // entry
}
formatter->close_section(); // categories
}
int RGWUsage::show(const DoutPrefixProvider *dpp, rgw::sal::Driver* driver,
rgw::sal::User* user , rgw::sal::Bucket* bucket,
uint64_t start_epoch, uint64_t end_epoch, bool show_log_entries,
bool show_log_sum,
map<string, bool> *categories, RGWFormatterFlusher& flusher)
{
uint32_t max_entries = 1000;
bool is_truncated = true;
RGWUsageIter usage_iter;
Formatter *formatter = flusher.get_formatter();
map<rgw_user_bucket, rgw_usage_log_entry> usage;
flusher.start(0);
formatter->open_object_section("usage");
if (show_log_entries) {
formatter->open_array_section("entries");
}
string last_owner;
bool user_section_open = false;
map<string, rgw_usage_log_entry> summary_map;
int ret;
while (is_truncated) {
if (bucket) {
ret = bucket->read_usage(dpp, start_epoch, end_epoch, max_entries, &is_truncated,
usage_iter, usage);
} else if (user) {
ret = user->read_usage(dpp, start_epoch, end_epoch, max_entries, &is_truncated,
usage_iter, usage);
} else {
ret = driver->read_all_usage(dpp, start_epoch, end_epoch, max_entries, &is_truncated,
usage_iter, usage);
}
if (ret == -ENOENT) {
ret = 0;
is_truncated = false;
}
if (ret < 0) {
return ret;
}
map<rgw_user_bucket, rgw_usage_log_entry>::iterator iter;
for (iter = usage.begin(); iter != usage.end(); ++iter) {
const rgw_user_bucket& ub = iter->first;
const rgw_usage_log_entry& entry = iter->second;
if (show_log_entries) {
if (ub.user.compare(last_owner) != 0) {
if (user_section_open) {
formatter->close_section();
formatter->close_section();
}
formatter->open_object_section("user");
formatter->dump_string("user", ub.user);
formatter->open_array_section("buckets");
user_section_open = true;
last_owner = ub.user;
}
formatter->open_object_section("bucket");
formatter->dump_string("bucket", ub.bucket);
utime_t ut(entry.epoch, 0);
ut.gmtime(formatter->dump_stream("time"));
formatter->dump_int("epoch", entry.epoch);
string owner = entry.owner.to_str();
string payer = entry.payer.to_str();
formatter->dump_string("owner", owner);
if (!payer.empty() && payer != owner) {
formatter->dump_string("payer", payer);
}
dump_usage_categories_info(formatter, entry, categories);
formatter->close_section(); // bucket
flusher.flush();
}
summary_map[ub.user].aggregate(entry, categories);
}
}
if (show_log_entries) {
if (user_section_open) {
formatter->close_section(); // buckets
formatter->close_section(); //user
}
formatter->close_section(); // entries
}
if (show_log_sum) {
formatter->open_array_section("summary");
map<string, rgw_usage_log_entry>::iterator siter;
for (siter = summary_map.begin(); siter != summary_map.end(); ++siter) {
const rgw_usage_log_entry& entry = siter->second;
formatter->open_object_section("user");
formatter->dump_string("user", siter->first);
dump_usage_categories_info(formatter, entry, categories);
rgw_usage_data total_usage;
entry.sum(total_usage, *categories);
formatter->open_object_section("total");
encode_json("bytes_sent", total_usage.bytes_sent, formatter);
encode_json("bytes_received", total_usage.bytes_received, formatter);
encode_json("ops", total_usage.ops, formatter);
encode_json("successful_ops", total_usage.successful_ops, formatter);
formatter->close_section(); // total
formatter->close_section(); // user
flusher.flush();
}
formatter->close_section(); // summary
}
formatter->close_section(); // usage
flusher.flush();
return 0;
}
int RGWUsage::trim(const DoutPrefixProvider *dpp, rgw::sal::Driver* driver,
rgw::sal::User* user , rgw::sal::Bucket* bucket,
uint64_t start_epoch, uint64_t end_epoch, optional_yield y)
{
if (bucket) {
return bucket->trim_usage(dpp, start_epoch, end_epoch, y);
} else if (user) {
return user->trim_usage(dpp, start_epoch, end_epoch, y);
} else {
return driver->trim_all_usage(dpp, start_epoch, end_epoch, y);
}
}
int RGWUsage::clear(const DoutPrefixProvider *dpp, rgw::sal::Driver* driver, optional_yield y)
{
return driver->clear_usage(dpp, y);
}
| 5,637 | 31.77907 | 125 |
cc
|
null |
ceph-main/src/rgw/rgw_usage.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#pragma once
#include <string>
#include <map>
#include "common/Formatter.h"
#include "common/dout.h"
#include "rgw_formats.h"
#include "rgw_user.h"
#include "rgw_sal_fwd.h"
class RGWUsage
{
public:
static int show(const DoutPrefixProvider *dpp, rgw::sal::Driver* driver,
rgw::sal::User* user , rgw::sal::Bucket* bucket,
uint64_t start_epoch, uint64_t end_epoch, bool show_log_entries,
bool show_log_sum,
std::map<std::string, bool> *categories, RGWFormatterFlusher& flusher);
static int trim(const DoutPrefixProvider *dpp, rgw::sal::Driver* driver,
rgw::sal::User* user , rgw::sal::Bucket* bucket,
uint64_t start_epoch, uint64_t end_epoch, optional_yield y);
static int clear(const DoutPrefixProvider *dpp, rgw::sal::Driver* driver, optional_yield y);
};
| 897 | 27.967742 | 94 |
h
|
null |
ceph-main/src/rgw/rgw_user.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#include "rgw_sal_rados.h"
#include "include/types.h"
#include "rgw_user.h"
// until everything is moved from rgw_common
#include "rgw_common.h"
#define dout_subsys ceph_subsys_rgw
using namespace std;
int rgw_user_sync_all_stats(const DoutPrefixProvider *dpp, rgw::sal::Driver* driver,
rgw::sal::User* user, optional_yield y)
{
rgw::sal::BucketList user_buckets;
CephContext *cct = driver->ctx();
size_t max_entries = cct->_conf->rgw_list_buckets_max_chunk;
string marker;
int ret;
do {
ret = user->list_buckets(dpp, marker, string(), max_entries, false, user_buckets, y);
if (ret < 0) {
ldpp_dout(dpp, 0) << "failed to read user buckets: ret=" << ret << dendl;
return ret;
}
auto& buckets = user_buckets.get_buckets();
for (auto i = buckets.begin(); i != buckets.end(); ++i) {
marker = i->first;
auto& bucket = i->second;
ret = bucket->load_bucket(dpp, y);
if (ret < 0) {
ldpp_dout(dpp, 0) << "ERROR: could not read bucket info: bucket=" << bucket << " ret=" << ret << dendl;
continue;
}
ret = bucket->sync_user_stats(dpp, y);
if (ret < 0) {
ldout(cct, 0) << "ERROR: could not sync bucket stats: ret=" << ret << dendl;
return ret;
}
ret = bucket->check_bucket_shards(dpp, y);
if (ret < 0) {
ldpp_dout(dpp, 0) << "ERROR in check_bucket_shards: " << cpp_strerror(-ret)<< dendl;
}
}
} while (user_buckets.is_truncated());
ret = user->complete_flush_stats(dpp, y);
if (ret < 0) {
cerr << "ERROR: failed to complete syncing user stats: ret=" << ret << std::endl;
return ret;
}
return 0;
}
int rgw_user_get_all_buckets_stats(const DoutPrefixProvider *dpp,
rgw::sal::Driver* driver,
rgw::sal::User* user,
map<string, bucket_meta_entry>& buckets_usage_map,
optional_yield y)
{
CephContext *cct = driver->ctx();
size_t max_entries = cct->_conf->rgw_list_buckets_max_chunk;
bool done;
string marker;
int ret;
do {
rgw::sal::BucketList buckets;
ret = user->list_buckets(dpp, marker, string(), max_entries, false, buckets, y);
if (ret < 0) {
ldpp_dout(dpp, 0) << "failed to read user buckets: ret=" << ret << dendl;
return ret;
}
auto& m = buckets.get_buckets();
for (const auto& i : m) {
marker = i.first;
auto& bucket_ent = i.second;
ret = bucket_ent->load_bucket(dpp, y, true /* load user stats */);
if (ret < 0) {
ldpp_dout(dpp, 0) << "ERROR: could not get bucket stats: ret=" << ret << dendl;
return ret;
}
bucket_meta_entry entry;
entry.size = bucket_ent->get_size();
entry.size_rounded = bucket_ent->get_size_rounded();
entry.creation_time = bucket_ent->get_creation_time();
entry.count = bucket_ent->get_count();
buckets_usage_map.emplace(bucket_ent->get_name(), entry);
}
done = (buckets.count() < max_entries);
} while (!done);
return 0;
}
int rgw_validate_tenant_name(const string& t)
{
struct tench {
static bool is_good(char ch) {
return isalnum(ch) || ch == '_';
}
};
std::string::const_iterator it =
std::find_if_not(t.begin(), t.end(), tench::is_good);
return (it == t.end())? 0: -ERR_INVALID_TENANT_NAME;
}
/**
* Get the anonymous (ie, unauthenticated) user info.
*/
void rgw_get_anon_user(RGWUserInfo& info)
{
info.user_id = RGW_USER_ANON_ID;
info.display_name.clear();
info.access_keys.clear();
}
| 3,607 | 27.1875 | 111 |
cc
|
null |
ceph-main/src/rgw/rgw_user_types.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2019 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
/* N.B., this header defines fundamental serialized types. Do not
* include files which can only be compiled in radosgw or OSD
* contexts (e.g., rgw_sal.h, rgw_common.h) */
#pragma once
#include <string_view>
#include <fmt/format.h>
#include "common/dout.h"
#include "common/Formatter.h"
struct rgw_user {
std::string tenant;
std::string id;
std::string ns;
rgw_user() {}
explicit rgw_user(const std::string& s) {
from_str(s);
}
rgw_user(const std::string& tenant, const std::string& id, const std::string& ns="")
: tenant(tenant),
id(id),
ns(ns) {
}
rgw_user(std::string&& tenant, std::string&& id, std::string&& ns="")
: tenant(std::move(tenant)),
id(std::move(id)),
ns(std::move(ns)) {
}
void encode(ceph::buffer::list& bl) const {
ENCODE_START(2, 1, bl);
encode(tenant, bl);
encode(id, bl);
encode(ns, bl);
ENCODE_FINISH(bl);
}
void decode(ceph::buffer::list::const_iterator& bl) {
DECODE_START(2, bl);
decode(tenant, bl);
decode(id, bl);
if (struct_v >= 2) {
decode(ns, bl);
}
DECODE_FINISH(bl);
}
void to_str(std::string& str) const {
if (!tenant.empty()) {
if (!ns.empty()) {
str = tenant + '$' + ns + '$' + id;
} else {
str = tenant + '$' + id;
}
} else if (!ns.empty()) {
str = '$' + ns + '$' + id;
} else {
str = id;
}
}
void clear() {
tenant.clear();
id.clear();
ns.clear();
}
bool empty() const {
return id.empty();
}
std::string to_str() const {
std::string s;
to_str(s);
return s;
}
void from_str(const std::string& str) {
size_t pos = str.find('$');
if (pos != std::string::npos) {
tenant = str.substr(0, pos);
std::string_view sv = str;
std::string_view ns_id = sv.substr(pos + 1);
size_t ns_pos = ns_id.find('$');
if (ns_pos != std::string::npos) {
ns = std::string(ns_id.substr(0, ns_pos));
id = std::string(ns_id.substr(ns_pos + 1));
} else {
ns.clear();
id = std::string(ns_id);
}
} else {
tenant.clear();
ns.clear();
id = str;
}
}
rgw_user& operator=(const std::string& str) {
from_str(str);
return *this;
}
int compare(const rgw_user& u) const {
int r = tenant.compare(u.tenant);
if (r != 0)
return r;
r = ns.compare(u.ns);
if (r != 0) {
return r;
}
return id.compare(u.id);
}
int compare(const std::string& str) const {
rgw_user u(str);
return compare(u);
}
bool operator!=(const rgw_user& rhs) const {
return (compare(rhs) != 0);
}
bool operator==(const rgw_user& rhs) const {
return (compare(rhs) == 0);
}
bool operator<(const rgw_user& rhs) const {
if (tenant < rhs.tenant) {
return true;
} else if (tenant > rhs.tenant) {
return false;
}
if (ns < rhs.ns) {
return true;
} else if (ns > rhs.ns) {
return false;
}
return (id < rhs.id);
}
void dump(ceph::Formatter *f) const;
static void generate_test_instances(std::list<rgw_user*>& o);
};
WRITE_CLASS_ENCODER(rgw_user)
| 3,596 | 21.622642 | 86 |
h
|
null |
ceph-main/src/rgw/rgw_web_idp.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#pragma once
namespace rgw {
namespace web_idp {
//WebToken contains some claims from the decoded token which are of interest to us.
struct WebTokenClaims {
//Subject of the token
std::string sub;
//Intended audience for this token
std::string aud;
//Issuer of this token
std::string iss;
//Human-readable id for the resource owner
std::string user_name;
//Client Id
std::string client_id;
//azp
std::string azp;
};
}; /* namespace web_idp */
}; /* namespace rgw */
| 599 | 21.222222 | 83 |
h
|
null |
ceph-main/src/rgw/rgw_website.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2015 Yehuda Sadeh <[email protected]>
* Copyright (C) 2015 Robin H. Johnson <[email protected]>
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "common/debug.h"
#include "common/ceph_json.h"
#include "common/Formatter.h"
#include "acconfig.h"
#include <errno.h>
#include <string>
#include <list>
#include "include/types.h"
#include "rgw_website.h"
#include "rgw_common.h"
#include "rgw_xml.h"
using namespace std;
bool RGWBWRoutingRuleCondition::check_key_condition(const string& key) {
return (key.size() >= key_prefix_equals.size() &&
key.compare(0, key_prefix_equals.size(), key_prefix_equals) == 0);
}
void RGWBWRoutingRule::apply_rule(const string& default_protocol, const string& default_hostname,
const string& key, string *new_url, int *redirect_code)
{
RGWRedirectInfo& redirect = redirect_info.redirect;
string protocol = (!redirect.protocol.empty() ? redirect.protocol : default_protocol);
string hostname = (!redirect.hostname.empty() ? redirect.hostname : default_hostname);
*new_url = protocol + "://" + hostname + "/";
if (!redirect_info.replace_key_prefix_with.empty()) {
*new_url += redirect_info.replace_key_prefix_with;
if (key.size() > condition.key_prefix_equals.size()) {
*new_url += key.substr(condition.key_prefix_equals.size());
}
} else if (!redirect_info.replace_key_with.empty()) {
*new_url += redirect_info.replace_key_with;
} else {
*new_url += key;
}
if(redirect.http_redirect_code > 0)
*redirect_code = redirect.http_redirect_code;
}
bool RGWBWRoutingRules::check_key_and_error_code_condition(const string &key, int error_code, RGWBWRoutingRule **rule)
{
for (list<RGWBWRoutingRule>::iterator iter = rules.begin(); iter != rules.end(); ++iter) {
if (iter->check_key_condition(key) && iter->check_error_code_condition(error_code)) {
*rule = &(*iter);
return true;
}
}
return false;
}
bool RGWBWRoutingRules::check_key_condition(const string& key, RGWBWRoutingRule **rule)
{
for (list<RGWBWRoutingRule>::iterator iter = rules.begin(); iter != rules.end(); ++iter) {
if (iter->check_key_condition(key)) {
*rule = &(*iter);
return true;
}
}
return false;
}
bool RGWBWRoutingRules::check_error_code_condition(const int http_error_code, RGWBWRoutingRule **rule)
{
for (list<RGWBWRoutingRule>::iterator iter = rules.begin(); iter != rules.end(); ++iter) {
if (iter->check_error_code_condition(http_error_code)) {
*rule = &(*iter);
return true;
}
}
return false;
}
bool RGWBucketWebsiteConf::should_redirect(const string& key, const int http_error_code, RGWBWRoutingRule *redirect)
{
RGWBWRoutingRule *rule;
if(!redirect_all.hostname.empty()) {
RGWBWRoutingRule redirect_all_rule;
redirect_all_rule.redirect_info.redirect = redirect_all;
redirect_all.http_redirect_code = 301;
*redirect = redirect_all_rule;
return true;
} else if (!routing_rules.check_key_and_error_code_condition(key, http_error_code, &rule)) {
return false;
}
*redirect = *rule;
return true;
}
bool RGWBucketWebsiteConf::get_effective_key(const string& key, string *effective_key, bool is_file) const
{
if (index_doc_suffix.empty()) {
return false;
}
if (key.empty()) {
*effective_key = index_doc_suffix;
} else if (key[key.size() - 1] == '/') {
*effective_key = key + index_doc_suffix;
} else if (! is_file) {
*effective_key = key + "/" + index_doc_suffix;
} else {
*effective_key = key;
}
return true;
}
void RGWRedirectInfo::dump(Formatter *f) const
{
encode_json("protocol", protocol, f);
encode_json("hostname", hostname, f);
encode_json("http_redirect_code", (int)http_redirect_code, f);
}
void RGWRedirectInfo::decode_json(JSONObj *obj) {
JSONDecoder::decode_json("protocol", protocol, obj);
JSONDecoder::decode_json("hostname", hostname, obj);
int code;
JSONDecoder::decode_json("http_redirect_code", code, obj);
http_redirect_code = code;
}
void RGWBWRedirectInfo::dump(Formatter *f) const
{
encode_json("redirect", redirect, f);
encode_json("replace_key_prefix_with", replace_key_prefix_with, f);
encode_json("replace_key_with", replace_key_with, f);
}
void RGWBWRedirectInfo::decode_json(JSONObj *obj) {
JSONDecoder::decode_json("redirect", redirect, obj);
JSONDecoder::decode_json("replace_key_prefix_with", replace_key_prefix_with, obj);
JSONDecoder::decode_json("replace_key_with", replace_key_with, obj);
}
void RGWBWRoutingRuleCondition::dump(Formatter *f) const
{
encode_json("key_prefix_equals", key_prefix_equals, f);
encode_json("http_error_code_returned_equals", (int)http_error_code_returned_equals, f);
}
void RGWBWRoutingRuleCondition::decode_json(JSONObj *obj) {
JSONDecoder::decode_json("key_prefix_equals", key_prefix_equals, obj);
int code;
JSONDecoder::decode_json("http_error_code_returned_equals", code, obj);
http_error_code_returned_equals = code;
}
void RGWBWRoutingRule::dump(Formatter *f) const
{
encode_json("condition", condition, f);
encode_json("redirect_info", redirect_info, f);
}
void RGWBWRoutingRule::decode_json(JSONObj *obj) {
JSONDecoder::decode_json("condition", condition, obj);
JSONDecoder::decode_json("redirect_info", redirect_info, obj);
}
void RGWBWRoutingRules::dump(Formatter *f) const
{
encode_json("rules", rules, f);
}
void RGWBWRoutingRules::decode_json(JSONObj *obj) {
JSONDecoder::decode_json("rules", rules, obj);
}
void RGWBucketWebsiteConf::dump(Formatter *f) const
{
if (!redirect_all.hostname.empty()) {
encode_json("redirect_all", redirect_all, f);
} else {
encode_json("index_doc_suffix", index_doc_suffix, f);
encode_json("error_doc", error_doc, f);
encode_json("routing_rules", routing_rules, f);
}
}
void RGWBucketWebsiteConf::decode_json(JSONObj *obj) {
JSONDecoder::decode_json("redirect_all", redirect_all, obj);
JSONDecoder::decode_json("index_doc_suffix", index_doc_suffix, obj);
JSONDecoder::decode_json("error_doc", error_doc, obj);
JSONDecoder::decode_json("routing_rules", routing_rules, obj);
}
void RGWBWRedirectInfo::dump_xml(Formatter *f) const
{
if (!redirect.protocol.empty()) {
encode_xml("Protocol", redirect.protocol, f);
}
if (!redirect.hostname.empty()) {
encode_xml("HostName", redirect.hostname, f);
}
if (redirect.http_redirect_code > 0) {
encode_xml("HttpRedirectCode", (int)redirect.http_redirect_code, f);
}
if (!replace_key_prefix_with.empty()) {
encode_xml("ReplaceKeyPrefixWith", replace_key_prefix_with, f);
}
if (!replace_key_with.empty()) {
encode_xml("ReplaceKeyWith", replace_key_with, f);
}
}
#define WEBSITE_HTTP_REDIRECT_CODE_MIN 300
#define WEBSITE_HTTP_REDIRECT_CODE_MAX 400
void RGWBWRedirectInfo::decode_xml(XMLObj *obj) {
RGWXMLDecoder::decode_xml("Protocol", redirect.protocol, obj);
RGWXMLDecoder::decode_xml("HostName", redirect.hostname, obj);
int code = 0;
bool has_http_redirect_code = RGWXMLDecoder::decode_xml("HttpRedirectCode", code, obj);
if (has_http_redirect_code &&
!(code > WEBSITE_HTTP_REDIRECT_CODE_MIN &&
code < WEBSITE_HTTP_REDIRECT_CODE_MAX)) {
throw RGWXMLDecoder::err("The provided HTTP redirect code is not valid. Valid codes are 3XX except 300.");
}
redirect.http_redirect_code = code;
bool has_replace_key_prefix_with = RGWXMLDecoder::decode_xml("ReplaceKeyPrefixWith", replace_key_prefix_with, obj);
bool has_replace_key_with = RGWXMLDecoder::decode_xml("ReplaceKeyWith", replace_key_with, obj);
if (has_replace_key_prefix_with && has_replace_key_with) {
throw RGWXMLDecoder::err("You can only define ReplaceKeyPrefix or ReplaceKey but not both.");
}
}
void RGWBWRoutingRuleCondition::dump_xml(Formatter *f) const
{
if (!key_prefix_equals.empty()) {
encode_xml("KeyPrefixEquals", key_prefix_equals, f);
}
if (http_error_code_returned_equals > 0) {
encode_xml("HttpErrorCodeReturnedEquals", (int)http_error_code_returned_equals, f);
}
}
#define WEBSITE_HTTP_ERROR_CODE_RETURNED_EQUALS_MIN 400
#define WEBSITE_HTTP_ERROR_CODE_RETURNED_EQUALS_MAX 600
void RGWBWRoutingRuleCondition::decode_xml(XMLObj *obj) {
RGWXMLDecoder::decode_xml("KeyPrefixEquals", key_prefix_equals, obj);
int code = 0;
bool has_http_error_code_returned_equals = RGWXMLDecoder::decode_xml("HttpErrorCodeReturnedEquals", code, obj);
if (has_http_error_code_returned_equals &&
!(code >= WEBSITE_HTTP_ERROR_CODE_RETURNED_EQUALS_MIN &&
code < WEBSITE_HTTP_ERROR_CODE_RETURNED_EQUALS_MAX)) {
throw RGWXMLDecoder::err("The provided HTTP redirect code is not valid. Valid codes are 4XX or 5XX.");
}
http_error_code_returned_equals = code;
}
void RGWBWRoutingRule::dump_xml(Formatter *f) const
{
encode_xml("Condition", condition, f);
encode_xml("Redirect", redirect_info, f);
}
void RGWBWRoutingRule::decode_xml(XMLObj *obj) {
RGWXMLDecoder::decode_xml("Condition", condition, obj);
RGWXMLDecoder::decode_xml("Redirect", redirect_info, obj);
}
static void encode_xml(const char *name, const std::list<RGWBWRoutingRule>& l, ceph::Formatter *f)
{
do_encode_xml("RoutingRules", l, "RoutingRule", f);
}
void RGWBucketWebsiteConf::dump_xml(Formatter *f) const
{
if (!redirect_all.hostname.empty()) {
f->open_object_section("RedirectAllRequestsTo");
encode_xml("HostName", redirect_all.hostname, f);
if (!redirect_all.protocol.empty()) {
encode_xml("Protocol", redirect_all.protocol, f);
}
f->close_section();
}
if (!index_doc_suffix.empty()) {
f->open_object_section("IndexDocument");
encode_xml("Suffix", index_doc_suffix, f);
f->close_section();
}
if (!error_doc.empty()) {
f->open_object_section("ErrorDocument");
encode_xml("Key", error_doc, f);
f->close_section();
}
if (!routing_rules.rules.empty()) {
encode_xml("RoutingRules", routing_rules.rules, f);
}
}
void decode_xml_obj(list<RGWBWRoutingRule>& l, XMLObj *obj)
{
do_decode_xml_obj(l, "RoutingRule", obj);
}
void RGWBucketWebsiteConf::decode_xml(XMLObj *obj) {
XMLObj *o = obj->find_first("RedirectAllRequestsTo");
if (o) {
is_redirect_all = true;
RGWXMLDecoder::decode_xml("HostName", redirect_all.hostname, o, true);
RGWXMLDecoder::decode_xml("Protocol", redirect_all.protocol, o);
} else {
o = obj->find_first("IndexDocument");
if (o) {
is_set_index_doc = true;
RGWXMLDecoder::decode_xml("Suffix", index_doc_suffix, o);
}
o = obj->find_first("ErrorDocument");
if (o) {
RGWXMLDecoder::decode_xml("Key", error_doc, o);
}
RGWXMLDecoder::decode_xml("RoutingRules", routing_rules.rules, obj);
}
}
| 11,080 | 31.400585 | 118 |
cc
|
null |
ceph-main/src/rgw/rgw_website.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2015 Yehuda Sadeh <[email protected]>
* Copyright (C) 2015 Robin H. Johnson <[email protected]>
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#pragma once
#include <list>
#include <string>
#include "common/ceph_json.h"
#include "rgw_xml.h"
struct RGWRedirectInfo
{
std::string protocol;
std::string hostname;
uint16_t http_redirect_code = 0;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(protocol, bl);
encode(hostname, bl);
encode(http_redirect_code, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(protocol, bl);
decode(hostname, bl);
decode(http_redirect_code, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
};
WRITE_CLASS_ENCODER(RGWRedirectInfo)
struct RGWBWRedirectInfo
{
RGWRedirectInfo redirect;
std::string replace_key_prefix_with;
std::string replace_key_with;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(redirect, bl);
encode(replace_key_prefix_with, bl);
encode(replace_key_with, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(redirect, bl);
decode(replace_key_prefix_with, bl);
decode(replace_key_with, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void dump_xml(Formatter *f) const;
void decode_json(JSONObj *obj);
void decode_xml(XMLObj *obj);
};
WRITE_CLASS_ENCODER(RGWBWRedirectInfo)
struct RGWBWRoutingRuleCondition
{
std::string key_prefix_equals;
uint16_t http_error_code_returned_equals = 0;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(key_prefix_equals, bl);
encode(http_error_code_returned_equals, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(key_prefix_equals, bl);
decode(http_error_code_returned_equals, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void dump_xml(Formatter *f) const;
void decode_json(JSONObj *obj);
void decode_xml(XMLObj *obj);
bool check_key_condition(const std::string& key);
bool check_error_code_condition(const int error_code) {
return (uint16_t)error_code == http_error_code_returned_equals;
}
};
WRITE_CLASS_ENCODER(RGWBWRoutingRuleCondition)
struct RGWBWRoutingRule
{
RGWBWRoutingRuleCondition condition;
RGWBWRedirectInfo redirect_info;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(condition, bl);
encode(redirect_info, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(condition, bl);
decode(redirect_info, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void dump_xml(Formatter *f) const;
void decode_json(JSONObj *obj);
void decode_xml(XMLObj *obj);
bool check_key_condition(const std::string& key) {
return condition.check_key_condition(key);
}
bool check_error_code_condition(int error_code) {
return condition.check_error_code_condition(error_code);
}
void apply_rule(const std::string& default_protocol,
const std::string& default_hostname,
const std::string& key,
std::string *redirect,
int *redirect_code);
};
WRITE_CLASS_ENCODER(RGWBWRoutingRule)
struct RGWBWRoutingRules
{
std::list<RGWBWRoutingRule> rules;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(rules, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(rules, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void dump_xml(Formatter *f) const;
void decode_json(JSONObj *obj);
bool check_key_condition(const std::string& key, RGWBWRoutingRule **rule);
bool check_error_code_condition(int error_code, RGWBWRoutingRule **rule);
bool check_key_and_error_code_condition(const std::string& key,
const int error_code,
RGWBWRoutingRule **rule);
};
WRITE_CLASS_ENCODER(RGWBWRoutingRules)
struct RGWBucketWebsiteConf
{
RGWRedirectInfo redirect_all;
std::string index_doc_suffix;
std::string error_doc;
std::string subdir_marker;
std::string listing_css_doc;
bool listing_enabled;
bool is_redirect_all;
bool is_set_index_doc;
RGWBWRoutingRules routing_rules;
RGWBucketWebsiteConf()
: listing_enabled(false) {
is_redirect_all = false;
is_set_index_doc = false;
}
void encode(bufferlist& bl) const {
ENCODE_START(2, 1, bl);
encode(index_doc_suffix, bl);
encode(error_doc, bl);
encode(routing_rules, bl);
encode(redirect_all, bl);
encode(subdir_marker, bl);
encode(listing_css_doc, bl);
encode(listing_enabled, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(2, bl);
decode(index_doc_suffix, bl);
decode(error_doc, bl);
decode(routing_rules, bl);
decode(redirect_all, bl);
if (struct_v >= 2) {
decode(subdir_marker, bl);
decode(listing_css_doc, bl);
decode(listing_enabled, bl);
}
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
void decode_xml(XMLObj *obj);
void dump_xml(Formatter *f) const;
bool should_redirect(const std::string& key,
const int http_error_code,
RGWBWRoutingRule *redirect);
bool get_effective_key(const std::string& key,
std::string *effective_key, bool is_file) const;
const std::string& get_index_doc() const {
return index_doc_suffix;
}
bool is_empty() const {
return index_doc_suffix.empty() &&
error_doc.empty() &&
subdir_marker.empty() &&
listing_css_doc.empty() &&
! listing_enabled;
}
};
WRITE_CLASS_ENCODER(RGWBucketWebsiteConf)
| 6,407 | 25.262295 | 76 |
h
|
null |
ceph-main/src/rgw/rgw_worker.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2019 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#pragma once
#include <atomic>
#include "common/Thread.h"
#include "common/ceph_mutex.h"
#include "include/common_fwd.h"
class RGWRados;
class RGWRadosThread {
class Worker : public Thread, public DoutPrefixProvider {
CephContext *cct;
RGWRadosThread *processor;
ceph::mutex lock = ceph::make_mutex("RGWRadosThread::Worker");
ceph::condition_variable cond;
void wait() {
std::unique_lock l{lock};
cond.wait(l);
};
void wait_interval(const ceph::real_clock::duration& wait_time) {
std::unique_lock l{lock};
cond.wait_for(l, wait_time);
}
public:
Worker(CephContext *_cct, RGWRadosThread *_p) : cct(_cct), processor(_p) {}
void *entry() override;
void signal() {
std::lock_guard l{lock};
cond.notify_all();
}
CephContext *get_cct() const { return cct; }
unsigned get_subsys() const { return ceph_subsys_rgw; }
std::ostream& gen_prefix(std::ostream& out) const { return out << "rgw rados thread: "; }
};
Worker *worker;
protected:
CephContext *cct;
RGWRados *store;
std::atomic<bool> down_flag = { false };
std::string thread_name;
virtual uint64_t interval_msec() = 0;
virtual void stop_process() {}
public:
RGWRadosThread(RGWRados *_store, const std::string& thread_name = "radosgw")
: worker(NULL), cct(_store->ctx()), store(_store), thread_name(thread_name) {}
virtual ~RGWRadosThread() {
stop();
}
virtual int init(const DoutPrefixProvider *dpp) { return 0; }
virtual int process(const DoutPrefixProvider *dpp) = 0;
bool going_down() { return down_flag; }
void start();
void stop();
void signal() {
if (worker) {
worker->signal();
}
}
};
| 2,124 | 22.097826 | 91 |
h
|
null |
ceph-main/src/rgw/rgw_xml.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#include <string.h>
#include <iostream>
#include <map>
#include <expat.h>
#include "include/types.h"
#include "include/utime.h"
#include "rgw_xml.h"
using namespace std;
XMLObjIter::
XMLObjIter()
{
}
XMLObjIter::
~XMLObjIter()
{
}
void XMLObjIter::
set(const XMLObjIter::map_iter_t &_cur, const XMLObjIter::map_iter_t &_end)
{
cur = _cur;
end = _end;
}
XMLObj *XMLObjIter::
get_next()
{
XMLObj *obj = NULL;
if (cur != end) {
obj = cur->second;
++cur;
}
return obj;
}
bool XMLObjIter::get_name(std::string& name) const
{
if (cur == end) {
return false;
}
name = cur->first;
return true;
}
ostream& operator<<(ostream &out, const XMLObj &obj) {
out << obj.obj_type << ": " << obj.data;
return out;
}
XMLObj::
~XMLObj()
{
}
bool XMLObj::
xml_start(XMLObj *parent, const char *el, const char **attr)
{
this->parent = parent;
obj_type = el;
for (int i = 0; attr[i]; i += 2) {
attr_map[attr[i]] = std::string(attr[i + 1]);
}
return true;
}
bool XMLObj::
xml_end(const char *el)
{
return true;
}
void XMLObj::
xml_handle_data(const char *s, int len)
{
data.append(s, len);
}
const std::string& XMLObj::
XMLObj::get_data() const
{
return data;
}
const std::string& XMLObj::
XMLObj::get_obj_type() const
{
return obj_type;
}
XMLObj *XMLObj::
XMLObj::get_parent()
{
return parent;
}
void XMLObj::
add_child(const std::string& el, XMLObj *obj)
{
children.insert(std::pair<std::string, XMLObj *>(el, obj));
}
bool XMLObj::
get_attr(const std::string& name, std::string& attr) const
{
const std::map<std::string, std::string>::const_iterator iter = attr_map.find(name);
if (iter == attr_map.end())
return false;
attr = iter->second;
return true;
}
XMLObjIter XMLObj::
find(const std::string& name)
{
XMLObjIter iter;
const XMLObjIter::const_map_iter_t first = children.find(name);
XMLObjIter::const_map_iter_t last;
if (first != children.end()) {
last = children.upper_bound(name);
}else
last = children.end();
iter.set(first, last);
return iter;
}
XMLObjIter XMLObj::find_first()
{
XMLObjIter iter;
const XMLObjIter::const_map_iter_t first = children.begin();
const XMLObjIter::const_map_iter_t last = children.end();
iter.set(first, last);
return iter;
}
XMLObj *XMLObj::
find_first(const std::string& name)
{
const XMLObjIter::const_map_iter_t first = children.find(name);
if (first != children.end())
return first->second;
return nullptr;
}
RGWXMLParser::
RGWXMLParser() : buf(nullptr), buf_len(0), cur_obj(nullptr), success(true), init_called(false)
{
p = XML_ParserCreate(nullptr);
}
RGWXMLParser::
~RGWXMLParser()
{
XML_ParserFree(p);
free(buf);
std::list<XMLObj *>::const_iterator iter;
for (iter = allocated_objs.begin(); iter != allocated_objs.end(); ++iter) {
XMLObj *obj = *iter;
delete obj;
}
}
void RGWXMLParser::call_xml_start(void* user_data, const char *el, const char **attr) {
RGWXMLParser *handler = static_cast<RGWXMLParser *>(user_data);
XMLObj * obj = handler->alloc_obj(el);
if (!obj) {
handler->unallocated_objs.push_back(XMLObj());
obj = &handler->unallocated_objs.back();
} else {
handler->allocated_objs.push_back(obj);
}
if (!obj->xml_start(handler->cur_obj, el, attr)) {
handler->success = false;
return;
}
if (handler->cur_obj) {
handler->cur_obj->add_child(el, obj);
} else {
handler->children.insert(std::pair<std::string, XMLObj *>(el, obj));
}
handler->cur_obj = obj;
handler->objs.push_back(obj);
}
void RGWXMLParser::call_xml_end(void* user_data, const char *el) {
RGWXMLParser *handler = static_cast<RGWXMLParser *>(user_data);
XMLObj *parent_obj = handler->cur_obj->get_parent();
if (!handler->cur_obj->xml_end(el)) {
handler->success = false;
return;
}
handler->cur_obj = parent_obj;
}
void RGWXMLParser::call_xml_handle_data(void* user_data, const char *s, int len)
{
RGWXMLParser *handler = static_cast<RGWXMLParser *>(user_data);
handler->cur_obj->xml_handle_data(s, len);
}
bool RGWXMLParser::init()
{
if (!p) {
return false;
}
init_called = true;
XML_SetElementHandler(p, RGWXMLParser::call_xml_start, RGWXMLParser::call_xml_end);
XML_SetCharacterDataHandler(p, RGWXMLParser::call_xml_handle_data);
XML_SetUserData(p, (void *)this);
return true;
}
bool RGWXMLParser::parse(const char *_buf, int len, int done)
{
ceph_assert(init_called);
int pos = buf_len;
char *tmp_buf;
tmp_buf = (char *)realloc(buf, buf_len + len);
if (tmp_buf == NULL){
free(buf);
buf = NULL;
return false;
} else {
buf = tmp_buf;
}
memcpy(&buf[buf_len], _buf, len);
buf_len += len;
success = true;
if (!XML_Parse(p, &buf[pos], len, done)) {
fprintf(stderr, "Parse error at line %d:\n%s\n",
(int)XML_GetCurrentLineNumber(p),
XML_ErrorString(XML_GetErrorCode(p)));
success = false;
}
return success;
}
void decode_xml_obj(unsigned long& val, XMLObj *obj)
{
auto& s = obj->get_data();
const char *start = s.c_str();
char *p;
errno = 0;
val = strtoul(start, &p, 10);
/* Check for various possible errors */
if ((errno == ERANGE && val == ULONG_MAX) ||
(errno != 0 && val == 0)) {
throw RGWXMLDecoder::err("failed to number");
}
if (p == start) {
throw RGWXMLDecoder::err("failed to parse number");
}
while (*p != '\0') {
if (!isspace(*p)) {
throw RGWXMLDecoder::err("failed to parse number");
}
p++;
}
}
void decode_xml_obj(long& val, XMLObj *obj)
{
const std::string s = obj->get_data();
const char *start = s.c_str();
char *p;
errno = 0;
val = strtol(start, &p, 10);
/* Check for various possible errors */
if ((errno == ERANGE && (val == LONG_MAX || val == LONG_MIN)) ||
(errno != 0 && val == 0)) {
throw RGWXMLDecoder::err("failed to parse number");
}
if (p == start) {
throw RGWXMLDecoder::err("failed to parse number");
}
while (*p != '\0') {
if (!isspace(*p)) {
throw RGWXMLDecoder::err("failed to parse number");
}
p++;
}
}
void decode_xml_obj(long long& val, XMLObj *obj)
{
const std::string s = obj->get_data();
const char *start = s.c_str();
char *p;
errno = 0;
val = strtoll(start, &p, 10);
/* Check for various possible errors */
if ((errno == ERANGE && (val == LLONG_MAX || val == LLONG_MIN)) ||
(errno != 0 && val == 0)) {
throw RGWXMLDecoder::err("failed to parse number");
}
if (p == start) {
throw RGWXMLDecoder::err("failed to parse number");
}
while (*p != '\0') {
if (!isspace(*p)) {
throw RGWXMLDecoder::err("failed to parse number");
}
p++;
}
}
void decode_xml_obj(unsigned long long& val, XMLObj *obj)
{
const std::string s = obj->get_data();
const char *start = s.c_str();
char *p;
errno = 0;
val = strtoull(start, &p, 10);
/* Check for various possible errors */
if ((errno == ERANGE && val == ULLONG_MAX) ||
(errno != 0 && val == 0)) {
throw RGWXMLDecoder::err("failed to parse number");
}
if (p == start) {
throw RGWXMLDecoder::err("failed to parse number");
}
while (*p != '\0') {
if (!isspace(*p)) {
throw RGWXMLDecoder::err("failed to parse number");
}
p++;
}
}
void decode_xml_obj(int& val, XMLObj *obj)
{
long l;
decode_xml_obj(l, obj);
#if LONG_MAX > INT_MAX
if (l > INT_MAX || l < INT_MIN) {
throw RGWXMLDecoder::err("integer out of range");
}
#endif
val = (int)l;
}
void decode_xml_obj(unsigned& val, XMLObj *obj)
{
unsigned long l;
decode_xml_obj(l, obj);
#if ULONG_MAX > UINT_MAX
if (l > UINT_MAX) {
throw RGWXMLDecoder::err("unsigned integer out of range");
}
#endif
val = (unsigned)l;
}
void decode_xml_obj(bool& val, XMLObj *obj)
{
const std::string s = obj->get_data();
if (strncasecmp(s.c_str(), "true", 8) == 0) {
val = true;
return;
}
if (strncasecmp(s.c_str(), "false", 8) == 0) {
val = false;
return;
}
int i;
decode_xml_obj(i, obj);
val = (bool)i;
}
void decode_xml_obj(bufferlist& val, XMLObj *obj)
{
const std::string s = obj->get_data();
bufferlist bl;
bl.append(s.c_str(), s.size());
try {
val.decode_base64(bl);
} catch (buffer::error& err) {
throw RGWXMLDecoder::err("failed to decode base64");
}
}
void decode_xml_obj(utime_t& val, XMLObj *obj)
{
const std::string s = obj->get_data();
uint64_t epoch;
uint64_t nsec;
int r = utime_t::parse_date(s, &epoch, &nsec);
if (r == 0) {
val = utime_t(epoch, nsec);
} else {
throw RGWXMLDecoder::err("failed to decode utime_t");
}
}
void encode_xml(const char *name, const string& val, Formatter *f)
{
f->dump_string(name, val);
}
void encode_xml(const char *name, const char *val, Formatter *f)
{
f->dump_string(name, val);
}
void encode_xml(const char *name, bool val, Formatter *f)
{
std::string s;
if (val)
s = "True";
else
s = "False";
f->dump_string(name, s);
}
void encode_xml(const char *name, int val, Formatter *f)
{
f->dump_int(name, val);
}
void encode_xml(const char *name, long val, Formatter *f)
{
f->dump_int(name, val);
}
void encode_xml(const char *name, unsigned val, Formatter *f)
{
f->dump_unsigned(name, val);
}
void encode_xml(const char *name, unsigned long val, Formatter *f)
{
f->dump_unsigned(name, val);
}
void encode_xml(const char *name, unsigned long long val, Formatter *f)
{
f->dump_unsigned(name, val);
}
void encode_xml(const char *name, long long val, Formatter *f)
{
f->dump_int(name, val);
}
void encode_xml(const char *name, const utime_t& val, Formatter *f)
{
val.gmtime(f->dump_stream(name));
}
void encode_xml(const char *name, const bufferlist& bl, Formatter *f)
{
/* need to copy data from bl, as it is const bufferlist */
bufferlist src = bl;
bufferlist b64;
src.encode_base64(b64);
const std::string s(b64.c_str(), b64.length());
encode_xml(name, s, f);
}
| 10,001 | 18.884692 | 94 |
cc
|
null |
ceph-main/src/rgw/rgw_xml.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#pragma once
#include <map>
#include <stdexcept>
#include <string>
#include <iosfwd>
#include <include/types.h>
#include <common/Formatter.h>
class XMLObj;
class RGWXMLParser;
class XMLObjIter {
public:
typedef std::map<std::string, XMLObj *>::iterator map_iter_t;
typedef std::map<std::string, XMLObj *>::iterator const_map_iter_t;
XMLObjIter();
virtual ~XMLObjIter();
void set(const XMLObjIter::const_map_iter_t &_cur, const XMLObjIter::const_map_iter_t &_end);
XMLObj *get_next();
bool get_name(std::string& name) const;
private:
map_iter_t cur;
map_iter_t end;
};
/**
* Represents a block of XML.
* Give the class an XML blob, and it will parse the blob into
* an attr_name->value map.
* It shouldn't be the start point for any parsing. Look at RGWXMLParser for that.
*/
class XMLObj
{
private:
XMLObj *parent;
std::string obj_type;
protected:
std::string data;
std::multimap<std::string, XMLObj *> children;
std::map<std::string, std::string> attr_map;
// invoked at the beginning of the XML tag, and populate any attributes
bool xml_start(XMLObj *parent, const char *el, const char **attr);
// callback invoked at the end of the XML tag
// if objects are created while parsing, this should be overwritten in the drived class
virtual bool xml_end(const char *el);
// callback invoked for storing the data of the XML tag
// if data manipulation is needed this could be overwritten in the drived class
virtual void xml_handle_data(const char *s, int len);
// get the parent object
XMLObj *get_parent();
// add a child XML object
void add_child(const std::string& el, XMLObj *obj);
public:
XMLObj() : parent(nullptr) {}
virtual ~XMLObj();
// get the data (as string)
const std::string& get_data() const;
// get the type of the object (as string)
const std::string& get_obj_type() const;
bool get_attr(const std::string& name, std::string& attr) const;
// return a list of sub-tags matching the name
XMLObjIter find(const std::string& name);
// return the first sub-tag
XMLObjIter find_first();
// return the first sub-tags matching the name
XMLObj *find_first(const std::string& name);
friend std::ostream& operator<<(std::ostream &out, const XMLObj &obj);
friend RGWXMLParser;
};
struct XML_ParserStruct;
// an XML parser is an XML object without a parent (root of the tree)
// the parser could be used in 2 ways:
//
// (1) lazy object creation/intrusive API: usually used within the RGWXMLDecode namespace (as RGWXMLDecode::XMLParser)
// the parser will parse the input and store info, but will not generate the target object. The object can be allocated outside
// of the parser (stack or heap), and require to implement the decode_xml() API for the values to be populated.
// note that the decode_xml() calls may throw exceptions if parsing fails
//
// (2) object creation while parsing: a new class needs to be derived from RGWXMLParser and implement alloc_obj()
// API that should create a set of classes derived from XMLObj implementing xml_end() to create the actual target objects
//
// There could be a mix-and-match of the 2 types, control over that is in the alloc_obj() call
// deciding for which tags objects are allocate during parsing and for which tags object allocation is external
class RGWXMLParser : public XMLObj
{
private:
XML_ParserStruct *p;
char *buf;
int buf_len;
XMLObj *cur_obj;
std::vector<XMLObj *> objs;
std::list<XMLObj *> allocated_objs;
std::list<XMLObj> unallocated_objs;
bool success;
bool init_called;
// calls xml_start() on each parsed object
// passed as static callback to actual parser, passes itself as user_data
static void call_xml_start(void* user_data, const char *el, const char **attr);
// calls xml_end() on each parsed object
// passed as static callback to actual parser, passes itself as user_data
static void call_xml_end(void* user_data, const char *el);
// calls xml_handle_data() on each parsed object
// passed as static callback to actual parser, passes itself as user_data
static void call_xml_handle_data(void* user_data, const char *s, int len);
protected:
// if objects are created while parsing, this should be implemented in the derived class
// and be a factory for creating the classes derived from XMLObj
// note that not all sub-tags has to be constructed here, any such tag which is not
// constructed will be lazily created when decode_xml() is invoked on it
//
// note that in case of different tags sharing the same name at different levels
// this method should not be used
virtual XMLObj *alloc_obj(const char *el) {
return nullptr;
}
public:
RGWXMLParser();
virtual ~RGWXMLParser() override;
// initialize the parser, must be called before parsing
bool init();
// parse the XML buffer (can be invoked multiple times for incremental parsing)
// receives the buffer to parse, its length, and boolean indication (0,1)
// whether this is the final chunk of the buffer
bool parse(const char *buf, int len, int done);
// get the XML blob being parsed
const char *get_xml() const { return buf; }
};
namespace RGWXMLDecoder {
struct err : std::runtime_error {
using runtime_error::runtime_error;
};
typedef RGWXMLParser XMLParser;
template<class T>
bool decode_xml(const char *name, T& val, XMLObj* obj, bool mandatory = false);
template<class T>
bool decode_xml(const char *name, std::vector<T>& v, XMLObj* obj, bool mandatory = false);
template<class C>
bool decode_xml(const char *name, C& container, void (*cb)(C&, XMLObj *obj), XMLObj *obj, bool mandatory = false);
template<class T>
void decode_xml(const char *name, T& val, T& default_val, XMLObj* obj);
}
static inline std::ostream& operator<<(std::ostream &out, RGWXMLDecoder::err& err)
{
return out << err.what();
}
template<class T>
void decode_xml_obj(T& val, XMLObj *obj)
{
val.decode_xml(obj);
}
static inline void decode_xml_obj(std::string& val, XMLObj *obj)
{
val = obj->get_data();
}
void decode_xml_obj(unsigned long long& val, XMLObj *obj);
void decode_xml_obj(long long& val, XMLObj *obj);
void decode_xml_obj(unsigned long& val, XMLObj *obj);
void decode_xml_obj(long& val, XMLObj *obj);
void decode_xml_obj(unsigned& val, XMLObj *obj);
void decode_xml_obj(int& val, XMLObj *obj);
void decode_xml_obj(bool& val, XMLObj *obj);
void decode_xml_obj(bufferlist& val, XMLObj *obj);
class utime_t;
void decode_xml_obj(utime_t& val, XMLObj *obj);
template<class T>
void decode_xml_obj(std::optional<T>& val, XMLObj *obj)
{
val.emplace();
decode_xml_obj(*val, obj);
}
template<class T>
void do_decode_xml_obj(std::list<T>& l, const std::string& name, XMLObj *obj)
{
l.clear();
XMLObjIter iter = obj->find(name);
XMLObj *o;
while ((o = iter.get_next())) {
T val;
decode_xml_obj(val, o);
l.push_back(val);
}
}
template<class T>
bool RGWXMLDecoder::decode_xml(const char *name, T& val, XMLObj *obj, bool mandatory)
{
XMLObjIter iter = obj->find(name);
XMLObj *o = iter.get_next();
if (!o) {
if (mandatory) {
std::string s = "missing mandatory field " + std::string(name);
throw err(s);
}
val = T();
return false;
}
try {
decode_xml_obj(val, o);
} catch (const err& e) {
std::string s = std::string(name) + ": ";
s.append(e.what());
throw err(s);
}
return true;
}
template<class T>
bool RGWXMLDecoder::decode_xml(const char *name, std::vector<T>& v, XMLObj *obj, bool mandatory)
{
XMLObjIter iter = obj->find(name);
XMLObj *o = iter.get_next();
v.clear();
if (!o) {
if (mandatory) {
std::string s = "missing mandatory field " + std::string(name);
throw err(s);
}
return false;
}
do {
T val;
try {
decode_xml_obj(val, o);
} catch (const err& e) {
std::string s = std::string(name) + ": ";
s.append(e.what());
throw err(s);
}
v.push_back(val);
} while ((o = iter.get_next()));
return true;
}
template<class C>
bool RGWXMLDecoder::decode_xml(const char *name, C& container, void (*cb)(C&, XMLObj *), XMLObj *obj, bool mandatory)
{
container.clear();
XMLObjIter iter = obj->find(name);
XMLObj *o = iter.get_next();
if (!o) {
if (mandatory) {
std::string s = "missing mandatory field " + std::string(name);
throw err(s);
}
return false;
}
try {
decode_xml_obj(container, cb, o);
} catch (const err& e) {
std::string s = std::string(name) + ": ";
s.append(e.what());
throw err(s);
}
return true;
}
template<class T>
void RGWXMLDecoder::decode_xml(const char *name, T& val, T& default_val, XMLObj *obj)
{
XMLObjIter iter = obj->find(name);
XMLObj *o = iter.get_next();
if (!o) {
val = default_val;
return;
}
try {
decode_xml_obj(val, o);
} catch (const err& e) {
val = default_val;
std::string s = std::string(name) + ": ";
s.append(e.what());
throw err(s);
}
}
template<class T>
static void encode_xml(const char *name, const T& val, ceph::Formatter *f)
{
f->open_object_section(name);
val.dump_xml(f);
f->close_section();
}
template<class T>
static void encode_xml(const char *name, const char *ns, const T& val, ceph::Formatter *f)
{
f->open_object_section_in_ns(name, ns);
val.dump_xml(f);
f->close_section();
}
void encode_xml(const char *name, const std::string& val, ceph::Formatter *f);
void encode_xml(const char *name, const char *val, ceph::Formatter *f);
void encode_xml(const char *name, bool val, ceph::Formatter *f);
void encode_xml(const char *name, int val, ceph::Formatter *f);
void encode_xml(const char *name, unsigned val, ceph::Formatter *f);
void encode_xml(const char *name, long val, ceph::Formatter *f);
void encode_xml(const char *name, unsigned long val, ceph::Formatter *f);
void encode_xml(const char *name, long long val, ceph::Formatter *f);
void encode_xml(const char *name, const utime_t& val, ceph::Formatter *f);
void encode_xml(const char *name, const bufferlist& bl, ceph::Formatter *f);
void encode_xml(const char *name, long long unsigned val, ceph::Formatter *f);
template<class T>
static void do_encode_xml(const char *name, const std::list<T>& l, const char *entry_name, ceph::Formatter *f)
{
f->open_array_section(name);
for (typename std::list<T>::const_iterator iter = l.begin(); iter != l.end(); ++iter) {
encode_xml(entry_name, *iter, f);
}
f->close_section();
}
template<class T>
static void encode_xml(const char *name, const std::vector<T>& l, ceph::Formatter *f)
{
for (typename std::vector<T>::const_iterator iter = l.begin(); iter != l.end(); ++iter) {
encode_xml(name, *iter, f);
}
}
template<class T>
static void encode_xml(const char *name, const std::optional<T>& o, ceph::Formatter *f)
{
if (!o) {
return;
}
encode_xml(name, *o, f);
}
| 10,985 | 28.532258 | 127 |
h
|
null |
ceph-main/src/rgw/rgw_xml_enc.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2015 Yehuda Sadeh <[email protected]>
* Copyright (C) 2015 Robin H. Johnson <[email protected]>
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "rgw_common.h"
#include "rgw_xml.h"
#include "common/Formatter.h"
#define dout_subsys ceph_subsys_rgw
using namespace std;
| 639 | 23.615385 | 70 |
cc
|
null |
ceph-main/src/rgw/rgw_zone.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#include <optional>
#include "common/errno.h"
#include "rgw_zone.h"
#include "rgw_sal_config.h"
#include "rgw_sync.h"
#include "services/svc_zone.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rgw
namespace rgw_zone_defaults {
static std::string default_bucket_index_pool_suffix = "rgw.buckets.index";
static std::string default_storage_extra_pool_suffix = "rgw.buckets.non-ec";
static std::string zone_info_oid_prefix = "zone_info.";
std::string zone_names_oid_prefix = "zone_names.";
std::string region_info_oid_prefix = "region_info.";
std::string zone_group_info_oid_prefix = "zonegroup_info.";
std::string default_region_info_oid = "default.region";
std::string default_zone_group_info_oid = "default.zonegroup";
std::string region_map_oid = "region_map";
std::string default_zonegroup_name = "default";
std::string default_zone_name = "default";
std::string zonegroup_names_oid_prefix = "zonegroups_names.";
std::string RGW_DEFAULT_ZONE_ROOT_POOL = "rgw.root";
std::string RGW_DEFAULT_ZONEGROUP_ROOT_POOL = "rgw.root";
std::string RGW_DEFAULT_PERIOD_ROOT_POOL = "rgw.root";
std::string avail_pools = ".pools.avail";
std::string default_storage_pool_suffix = "rgw.buckets.data";
}
using namespace std;
using namespace rgw_zone_defaults;
void encode_json_plain(const char *name, const RGWAccessKey& val, Formatter *f)
{
f->open_object_section(name);
val.dump_plain(f);
f->close_section();
}
static void decode_zones(map<rgw_zone_id, RGWZone>& zones, JSONObj *o)
{
RGWZone z;
z.decode_json(o);
zones[z.id] = z;
}
static void decode_placement_targets(map<string, RGWZoneGroupPlacementTarget>& targets, JSONObj *o)
{
RGWZoneGroupPlacementTarget t;
t.decode_json(o);
targets[t.name] = t;
}
void RGWZone::generate_test_instances(list<RGWZone*> &o)
{
RGWZone *z = new RGWZone;
o.push_back(z);
o.push_back(new RGWZone);
}
void RGWZone::dump(Formatter *f) const
{
encode_json("id", id, f);
encode_json("name", name, f);
encode_json("endpoints", endpoints, f);
encode_json("log_meta", log_meta, f);
encode_json("log_data", log_data, f);
encode_json("bucket_index_max_shards", bucket_index_max_shards, f);
encode_json("read_only", read_only, f);
encode_json("tier_type", tier_type, f);
encode_json("sync_from_all", sync_from_all, f);
encode_json("sync_from", sync_from, f);
encode_json("redirect_zone", redirect_zone, f);
encode_json("supported_features", supported_features, f);
}
void RGWZone::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("id", id, obj);
JSONDecoder::decode_json("name", name, obj);
if (id.empty()) {
id = name;
}
JSONDecoder::decode_json("endpoints", endpoints, obj);
JSONDecoder::decode_json("log_meta", log_meta, obj);
JSONDecoder::decode_json("log_data", log_data, obj);
JSONDecoder::decode_json("bucket_index_max_shards", bucket_index_max_shards, obj);
JSONDecoder::decode_json("read_only", read_only, obj);
JSONDecoder::decode_json("tier_type", tier_type, obj);
JSONDecoder::decode_json("sync_from_all", sync_from_all, true, obj);
JSONDecoder::decode_json("sync_from", sync_from, obj);
JSONDecoder::decode_json("redirect_zone", redirect_zone, obj);
JSONDecoder::decode_json("supported_features", supported_features, obj);
}
int RGWSystemMetaObj::init(const DoutPrefixProvider *dpp, CephContext *_cct, RGWSI_SysObj *_sysobj_svc,
optional_yield y,
bool setup_obj, bool old_format)
{
reinit_instance(_cct, _sysobj_svc);
if (!setup_obj)
return 0;
if (old_format && id.empty()) {
id = name;
}
if (id.empty()) {
id = get_predefined_id(cct);
}
if (id.empty()) {
int r;
if (name.empty()) {
name = get_predefined_name(cct);
}
if (name.empty()) {
r = use_default(dpp, y, old_format);
if (r < 0) {
return r;
}
} else if (!old_format) {
r = read_id(dpp, name, id, y);
if (r < 0) {
if (r != -ENOENT) {
ldpp_dout(dpp, 0) << "error in read_id for object name: " << name << " : " << cpp_strerror(-r) << dendl;
}
return r;
}
}
}
return read_info(dpp, id, y, old_format);
}
RGWZoneGroup::~RGWZoneGroup() {}
const string RGWZoneGroup::get_default_oid(bool old_region_format) const
{
if (old_region_format) {
if (cct->_conf->rgw_default_region_info_oid.empty()) {
return default_region_info_oid;
}
return cct->_conf->rgw_default_region_info_oid;
}
string default_oid = cct->_conf->rgw_default_zonegroup_info_oid;
if (cct->_conf->rgw_default_zonegroup_info_oid.empty()) {
default_oid = default_zone_group_info_oid;
}
default_oid += "." + realm_id;
return default_oid;
}
const string& RGWZoneGroup::get_info_oid_prefix(bool old_region_format) const
{
if (old_region_format) {
return region_info_oid_prefix;
}
return zone_group_info_oid_prefix;
}
const string& RGWZoneGroup::get_names_oid_prefix() const
{
return zonegroup_names_oid_prefix;
}
string RGWZoneGroup::get_predefined_id(CephContext *cct) const {
return cct->_conf.get_val<string>("rgw_zonegroup_id");
}
const string& RGWZoneGroup::get_predefined_name(CephContext *cct) const {
return cct->_conf->rgw_zonegroup;
}
rgw_pool RGWZoneGroup::get_pool(CephContext *cct_) const
{
if (cct_->_conf->rgw_zonegroup_root_pool.empty()) {
return rgw_pool(RGW_DEFAULT_ZONEGROUP_ROOT_POOL);
}
return rgw_pool(cct_->_conf->rgw_zonegroup_root_pool);
}
int RGWZoneGroup::read_default_id(const DoutPrefixProvider *dpp, string& default_id, optional_yield y,
bool old_format)
{
if (realm_id.empty()) {
/* try using default realm */
RGWRealm realm;
int ret = realm.init(dpp, cct, sysobj_svc, y);
// no default realm exist
if (ret < 0) {
return read_id(dpp, default_zonegroup_name, default_id, y);
}
realm_id = realm.get_id();
}
return RGWSystemMetaObj::read_default_id(dpp, default_id, y, old_format);
}
int RGWSystemMetaObj::use_default(const DoutPrefixProvider *dpp, optional_yield y, bool old_format)
{
return read_default_id(dpp, id, y, old_format);
}
void RGWSystemMetaObj::reinit_instance(CephContext *_cct, RGWSI_SysObj *_sysobj_svc)
{
cct = _cct;
sysobj_svc = _sysobj_svc;
zone_svc = _sysobj_svc->get_zone_svc();
}
int RGWSystemMetaObj::read_info(const DoutPrefixProvider *dpp, const string& obj_id, optional_yield y,
bool old_format)
{
rgw_pool pool(get_pool(cct));
bufferlist bl;
string oid = get_info_oid_prefix(old_format) + obj_id;
auto sysobj = sysobj_svc->get_obj(rgw_raw_obj{pool, oid});
int ret = sysobj.rop().read(dpp, &bl, y);
if (ret < 0) {
ldpp_dout(dpp, 0) << "failed reading obj info from " << pool << ":" << oid << ": " << cpp_strerror(-ret) << dendl;
return ret;
}
using ceph::decode;
try {
auto iter = bl.cbegin();
decode(*this, iter);
} catch (buffer::error& err) {
ldpp_dout(dpp, 0) << "ERROR: failed to decode obj from " << pool << ":" << oid << dendl;
return -EIO;
}
return 0;
}
void RGWZoneGroup::decode_json(JSONObj *obj)
{
RGWSystemMetaObj::decode_json(obj);
if (id.empty()) {
derr << "old format " << dendl;
JSONDecoder::decode_json("name", name, obj);
id = name;
}
JSONDecoder::decode_json("api_name", api_name, obj);
JSONDecoder::decode_json("is_master", is_master, obj);
JSONDecoder::decode_json("endpoints", endpoints, obj);
JSONDecoder::decode_json("hostnames", hostnames, obj);
JSONDecoder::decode_json("hostnames_s3website", hostnames_s3website, obj);
JSONDecoder::decode_json("master_zone", master_zone, obj);
JSONDecoder::decode_json("zones", zones, decode_zones, obj);
JSONDecoder::decode_json("placement_targets", placement_targets, decode_placement_targets, obj);
string pr;
JSONDecoder::decode_json("default_placement", pr, obj);
default_placement.from_str(pr);
JSONDecoder::decode_json("realm_id", realm_id, obj);
JSONDecoder::decode_json("sync_policy", sync_policy, obj);
JSONDecoder::decode_json("enabled_features", enabled_features, obj);
}
RGWZoneParams::~RGWZoneParams() {}
void RGWZoneParams::decode_json(JSONObj *obj)
{
RGWSystemMetaObj::decode_json(obj);
JSONDecoder::decode_json("domain_root", domain_root, obj);
JSONDecoder::decode_json("control_pool", control_pool, obj);
JSONDecoder::decode_json("gc_pool", gc_pool, obj);
JSONDecoder::decode_json("lc_pool", lc_pool, obj);
JSONDecoder::decode_json("log_pool", log_pool, obj);
JSONDecoder::decode_json("intent_log_pool", intent_log_pool, obj);
JSONDecoder::decode_json("roles_pool", roles_pool, obj);
JSONDecoder::decode_json("reshard_pool", reshard_pool, obj);
JSONDecoder::decode_json("usage_log_pool", usage_log_pool, obj);
JSONDecoder::decode_json("user_keys_pool", user_keys_pool, obj);
JSONDecoder::decode_json("user_email_pool", user_email_pool, obj);
JSONDecoder::decode_json("user_swift_pool", user_swift_pool, obj);
JSONDecoder::decode_json("user_uid_pool", user_uid_pool, obj);
JSONDecoder::decode_json("otp_pool", otp_pool, obj);
JSONDecoder::decode_json("system_key", system_key, obj);
JSONDecoder::decode_json("placement_pools", placement_pools, obj);
JSONDecoder::decode_json("tier_config", tier_config, obj);
JSONDecoder::decode_json("realm_id", realm_id, obj);
JSONDecoder::decode_json("notif_pool", notif_pool, obj);
}
void RGWZoneParams::dump(Formatter *f) const
{
RGWSystemMetaObj::dump(f);
encode_json("domain_root", domain_root, f);
encode_json("control_pool", control_pool, f);
encode_json("gc_pool", gc_pool, f);
encode_json("lc_pool", lc_pool, f);
encode_json("log_pool", log_pool, f);
encode_json("intent_log_pool", intent_log_pool, f);
encode_json("usage_log_pool", usage_log_pool, f);
encode_json("roles_pool", roles_pool, f);
encode_json("reshard_pool", reshard_pool, f);
encode_json("user_keys_pool", user_keys_pool, f);
encode_json("user_email_pool", user_email_pool, f);
encode_json("user_swift_pool", user_swift_pool, f);
encode_json("user_uid_pool", user_uid_pool, f);
encode_json("otp_pool", otp_pool, f);
encode_json_plain("system_key", system_key, f);
encode_json("placement_pools", placement_pools, f);
encode_json("tier_config", tier_config, f);
encode_json("realm_id", realm_id, f);
encode_json("notif_pool", notif_pool, f);
}
int RGWZoneParams::init(const DoutPrefixProvider *dpp,
CephContext *cct, RGWSI_SysObj *sysobj_svc,
optional_yield y, bool setup_obj, bool old_format)
{
if (name.empty()) {
name = cct->_conf->rgw_zone;
}
return RGWSystemMetaObj::init(dpp, cct, sysobj_svc, y, setup_obj, old_format);
}
rgw_pool RGWZoneParams::get_pool(CephContext *cct) const
{
if (cct->_conf->rgw_zone_root_pool.empty()) {
return rgw_pool(RGW_DEFAULT_ZONE_ROOT_POOL);
}
return rgw_pool(cct->_conf->rgw_zone_root_pool);
}
const string RGWZoneParams::get_default_oid(bool old_format) const
{
if (old_format) {
return cct->_conf->rgw_default_zone_info_oid;
}
return cct->_conf->rgw_default_zone_info_oid + "." + realm_id;
}
const string& RGWZoneParams::get_names_oid_prefix() const
{
return zone_names_oid_prefix;
}
const string& RGWZoneParams::get_info_oid_prefix(bool old_format) const
{
return zone_info_oid_prefix;
}
string RGWZoneParams::get_predefined_id(CephContext *cct) const {
return cct->_conf.get_val<string>("rgw_zone_id");
}
const string& RGWZoneParams::get_predefined_name(CephContext *cct) const {
return cct->_conf->rgw_zone;
}
int RGWZoneParams::read_default_id(const DoutPrefixProvider *dpp, string& default_id, optional_yield y,
bool old_format)
{
if (realm_id.empty()) {
/* try using default realm */
RGWRealm realm;
int ret = realm.init(dpp, cct, sysobj_svc, y);
//no default realm exist
if (ret < 0) {
return read_id(dpp, default_zone_name, default_id, y);
}
realm_id = realm.get_id();
}
return RGWSystemMetaObj::read_default_id(dpp, default_id, y, old_format);
}
int RGWZoneParams::set_as_default(const DoutPrefixProvider *dpp, optional_yield y, bool exclusive)
{
if (realm_id.empty()) {
/* try using default realm */
RGWRealm realm;
int ret = realm.init(dpp, cct, sysobj_svc, y);
if (ret < 0) {
ldpp_dout(dpp, 10) << "could not read realm id: " << cpp_strerror(-ret) << dendl;
return -EINVAL;
}
realm_id = realm.get_id();
}
return RGWSystemMetaObj::set_as_default(dpp, y, exclusive);
}
int RGWZoneParams::create(const DoutPrefixProvider *dpp, optional_yield y, bool exclusive)
{
/* check for old pools config */
rgw_raw_obj obj(domain_root, avail_pools);
auto sysobj = sysobj_svc->get_obj(obj);
int r = sysobj.rop().stat(y, dpp);
if (r < 0) {
ldpp_dout(dpp, 10) << "couldn't find old data placement pools config, setting up new ones for the zone" << dendl;
/* a new system, let's set new placement info */
RGWZonePlacementInfo default_placement;
default_placement.index_pool = name + "." + default_bucket_index_pool_suffix;
rgw_pool pool = name + "." + default_storage_pool_suffix;
default_placement.storage_classes.set_storage_class(RGW_STORAGE_CLASS_STANDARD, &pool, nullptr);
default_placement.data_extra_pool = name + "." + default_storage_extra_pool_suffix;
placement_pools["default-placement"] = default_placement;
}
r = fix_pool_names(dpp, y);
if (r < 0) {
ldpp_dout(dpp, 0) << "ERROR: fix_pool_names returned r=" << r << dendl;
return r;
}
r = RGWSystemMetaObj::create(dpp, y, exclusive);
if (r < 0) {
return r;
}
// try to set as default. may race with another create, so pass exclusive=true
// so we don't override an existing default
r = set_as_default(dpp, y, true);
if (r < 0 && r != -EEXIST) {
ldpp_dout(dpp, 10) << "WARNING: failed to set zone as default, r=" << r << dendl;
}
return 0;
}
rgw_pool fix_zone_pool_dup(const set<rgw_pool>& pools,
const string& default_prefix,
const string& default_suffix,
const rgw_pool& suggested_pool)
{
string suggested_name = suggested_pool.to_str();
string prefix = default_prefix;
string suffix = default_suffix;
if (!suggested_pool.empty()) {
prefix = suggested_name.substr(0, suggested_name.find("."));
suffix = suggested_name.substr(prefix.length());
}
rgw_pool pool(prefix + suffix);
while (pools.count(pool)) {
pool = prefix + "_" + std::to_string(std::rand()) + suffix;
}
return pool;
}
void add_zone_pools(const RGWZoneParams& info,
std::set<rgw_pool>& pools)
{
pools.insert(info.domain_root);
pools.insert(info.control_pool);
pools.insert(info.gc_pool);
pools.insert(info.log_pool);
pools.insert(info.intent_log_pool);
pools.insert(info.usage_log_pool);
pools.insert(info.user_keys_pool);
pools.insert(info.user_email_pool);
pools.insert(info.user_swift_pool);
pools.insert(info.user_uid_pool);
pools.insert(info.otp_pool);
pools.insert(info.roles_pool);
pools.insert(info.reshard_pool);
pools.insert(info.oidc_pool);
pools.insert(info.notif_pool);
for (const auto& [pname, placement] : info.placement_pools) {
pools.insert(placement.index_pool);
for (const auto& [sname, sc] : placement.storage_classes.get_all()) {
if (sc.data_pool) {
pools.insert(sc.data_pool.get());
}
}
pools.insert(placement.data_extra_pool);
}
}
namespace rgw {
int get_zones_pool_set(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::ConfigStore* cfgstore,
std::string_view my_zone_id,
std::set<rgw_pool>& pools)
{
std::array<std::string, 128> zone_names;
rgw::sal::ListResult<std::string> listing;
do {
int r = cfgstore->list_zone_names(dpp, y, listing.next,
zone_names, listing);
if (r < 0) {
ldpp_dout(dpp, 0) << "failed to list zones with " << cpp_strerror(r) << dendl;
return r;
}
for (const auto& name : listing.entries) {
RGWZoneParams info;
r = cfgstore->read_zone_by_name(dpp, y, name, info, nullptr);
if (r < 0) {
ldpp_dout(dpp, 0) << "failed to load zone " << name
<< " with " << cpp_strerror(r) << dendl;
return r;
}
if (info.get_id() != my_zone_id) {
add_zone_pools(info, pools);
}
}
} while (!listing.next.empty());
return 0;
}
}
static int get_zones_pool_set(const DoutPrefixProvider *dpp,
CephContext* cct,
RGWSI_SysObj* sysobj_svc,
const list<string>& zone_names,
const string& my_zone_id,
set<rgw_pool>& pool_names,
optional_yield y)
{
for (const auto& name : zone_names) {
RGWZoneParams zone(name);
int r = zone.init(dpp, cct, sysobj_svc, y);
if (r < 0) {
ldpp_dout(dpp, 0) << "Error: failed to load zone " << name
<< " with " << cpp_strerror(-r) << dendl;
return r;
}
if (zone.get_id() != my_zone_id) {
add_zone_pools(zone, pool_names);
}
}
return 0;
}
int RGWZoneParams::fix_pool_names(const DoutPrefixProvider *dpp, optional_yield y)
{
list<string> zones;
int r = zone_svc->list_zones(dpp, zones);
if (r < 0) {
ldpp_dout(dpp, 10) << "WARNING: driver->list_zones() returned r=" << r << dendl;
}
set<rgw_pool> pools;
r = get_zones_pool_set(dpp, cct, sysobj_svc, zones, id, pools, y);
if (r < 0) {
ldpp_dout(dpp, 0) << "Error: get_zones_pool_names" << r << dendl;
return r;
}
domain_root = fix_zone_pool_dup(pools, name, ".rgw.meta:root", domain_root);
control_pool = fix_zone_pool_dup(pools, name, ".rgw.control", control_pool);
gc_pool = fix_zone_pool_dup(pools, name ,".rgw.log:gc", gc_pool);
lc_pool = fix_zone_pool_dup(pools, name ,".rgw.log:lc", lc_pool);
log_pool = fix_zone_pool_dup(pools, name, ".rgw.log", log_pool);
intent_log_pool = fix_zone_pool_dup(pools, name, ".rgw.log:intent", intent_log_pool);
usage_log_pool = fix_zone_pool_dup(pools, name, ".rgw.log:usage", usage_log_pool);
user_keys_pool = fix_zone_pool_dup(pools, name, ".rgw.meta:users.keys", user_keys_pool);
user_email_pool = fix_zone_pool_dup(pools, name, ".rgw.meta:users.email", user_email_pool);
user_swift_pool = fix_zone_pool_dup(pools, name, ".rgw.meta:users.swift", user_swift_pool);
user_uid_pool = fix_zone_pool_dup(pools, name, ".rgw.meta:users.uid", user_uid_pool);
roles_pool = fix_zone_pool_dup(pools, name, ".rgw.meta:roles", roles_pool);
reshard_pool = fix_zone_pool_dup(pools, name, ".rgw.log:reshard", reshard_pool);
otp_pool = fix_zone_pool_dup(pools, name, ".rgw.otp", otp_pool);
oidc_pool = fix_zone_pool_dup(pools, name, ".rgw.meta:oidc", oidc_pool);
notif_pool = fix_zone_pool_dup(pools, name ,".rgw.log:notif", notif_pool);
for(auto& iter : placement_pools) {
iter.second.index_pool = fix_zone_pool_dup(pools, name, "." + default_bucket_index_pool_suffix,
iter.second.index_pool);
for (auto& pi : iter.second.storage_classes.get_all()) {
if (pi.second.data_pool) {
rgw_pool& pool = pi.second.data_pool.get();
pool = fix_zone_pool_dup(pools, name, "." + default_storage_pool_suffix,
pool);
}
}
iter.second.data_extra_pool= fix_zone_pool_dup(pools, name, "." + default_storage_extra_pool_suffix,
iter.second.data_extra_pool);
}
return 0;
}
int RGWPeriodConfig::read(const DoutPrefixProvider *dpp, RGWSI_SysObj *sysobj_svc, const std::string& realm_id,
optional_yield y)
{
const auto& pool = get_pool(sysobj_svc->ctx());
const auto& oid = get_oid(realm_id);
bufferlist bl;
auto sysobj = sysobj_svc->get_obj(rgw_raw_obj{pool, oid});
int ret = sysobj.rop().read(dpp, &bl, y);
if (ret < 0) {
return ret;
}
using ceph::decode;
try {
auto iter = bl.cbegin();
decode(*this, iter);
} catch (buffer::error& err) {
return -EIO;
}
return 0;
}
int RGWPeriodConfig::write(const DoutPrefixProvider *dpp,
RGWSI_SysObj *sysobj_svc,
const std::string& realm_id, optional_yield y)
{
const auto& pool = get_pool(sysobj_svc->ctx());
const auto& oid = get_oid(realm_id);
bufferlist bl;
using ceph::encode;
encode(*this, bl);
auto sysobj = sysobj_svc->get_obj(rgw_raw_obj{pool, oid});
return sysobj.wop()
.set_exclusive(false)
.write(dpp, bl, y);
}
void RGWPeriodConfig::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("bucket_quota", quota.bucket_quota, obj);
JSONDecoder::decode_json("user_quota", quota.user_quota, obj);
JSONDecoder::decode_json("user_ratelimit", user_ratelimit, obj);
JSONDecoder::decode_json("bucket_ratelimit", bucket_ratelimit, obj);
JSONDecoder::decode_json("anonymous_ratelimit", anon_ratelimit, obj);
}
void RGWPeriodConfig::dump(Formatter *f) const
{
encode_json("bucket_quota", quota.bucket_quota, f);
encode_json("user_quota", quota.user_quota, f);
encode_json("user_ratelimit", user_ratelimit, f);
encode_json("bucket_ratelimit", bucket_ratelimit, f);
encode_json("anonymous_ratelimit", anon_ratelimit, f);
}
std::string RGWPeriodConfig::get_oid(const std::string& realm_id)
{
if (realm_id.empty()) {
return "period_config.default";
}
return "period_config." + realm_id;
}
rgw_pool RGWPeriodConfig::get_pool(CephContext *cct)
{
const auto& pool_name = cct->_conf->rgw_period_root_pool;
if (pool_name.empty()) {
return {RGW_DEFAULT_PERIOD_ROOT_POOL};
}
return {pool_name};
}
int RGWSystemMetaObj::delete_obj(const DoutPrefixProvider *dpp, optional_yield y, bool old_format)
{
rgw_pool pool(get_pool(cct));
/* check to see if obj is the default */
RGWDefaultSystemMetaObjInfo default_info;
int ret = read_default(dpp, default_info, get_default_oid(old_format), y);
if (ret < 0 && ret != -ENOENT)
return ret;
if (default_info.default_id == id || (old_format && default_info.default_id == name)) {
string oid = get_default_oid(old_format);
rgw_raw_obj default_named_obj(pool, oid);
auto sysobj = sysobj_svc->get_obj(default_named_obj);
ret = sysobj.wop().remove(dpp, y);
if (ret < 0) {
ldpp_dout(dpp, 0) << "Error delete default obj name " << name << ": " << cpp_strerror(-ret) << dendl;
return ret;
}
}
if (!old_format) {
string oid = get_names_oid_prefix() + name;
rgw_raw_obj object_name(pool, oid);
auto sysobj = sysobj_svc->get_obj(object_name);
ret = sysobj.wop().remove(dpp, y);
if (ret < 0) {
ldpp_dout(dpp, 0) << "Error delete obj name " << name << ": " << cpp_strerror(-ret) << dendl;
return ret;
}
}
string oid = get_info_oid_prefix(old_format);
if (old_format) {
oid += name;
} else {
oid += id;
}
rgw_raw_obj object_id(pool, oid);
auto sysobj = sysobj_svc->get_obj(object_id);
ret = sysobj.wop().remove(dpp, y);
if (ret < 0) {
ldpp_dout(dpp, 0) << "Error delete object id " << id << ": " << cpp_strerror(-ret) << dendl;
}
return ret;
}
void RGWZoneGroup::dump(Formatter *f) const
{
RGWSystemMetaObj::dump(f);
encode_json("api_name", api_name, f);
encode_json("is_master", is_master, f);
encode_json("endpoints", endpoints, f);
encode_json("hostnames", hostnames, f);
encode_json("hostnames_s3website", hostnames_s3website, f);
encode_json("master_zone", master_zone, f);
encode_json_map("zones", zones, f); /* more friendly representation */
encode_json_map("placement_targets", placement_targets, f); /* more friendly representation */
encode_json("default_placement", default_placement, f);
encode_json("realm_id", realm_id, f);
encode_json("sync_policy", sync_policy, f);
encode_json("enabled_features", enabled_features, f);
}
void RGWZoneGroupPlacementTarget::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("name", name, obj);
JSONDecoder::decode_json("tags", tags, obj);
JSONDecoder::decode_json("storage_classes", storage_classes, obj);
if (storage_classes.empty()) {
storage_classes.insert(RGW_STORAGE_CLASS_STANDARD);
}
JSONDecoder::decode_json("tier_targets", tier_targets, obj);
}
void RGWZonePlacementInfo::dump(Formatter *f) const
{
encode_json("index_pool", index_pool, f);
encode_json("storage_classes", storage_classes, f);
encode_json("data_extra_pool", data_extra_pool, f);
encode_json("index_type", (uint32_t)index_type, f);
encode_json("inline_data", inline_data, f);
/* no real need for backward compatibility of compression_type and data_pool in here,
* rather not clutter the output */
}
void RGWZonePlacementInfo::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("index_pool", index_pool, obj);
JSONDecoder::decode_json("storage_classes", storage_classes, obj);
JSONDecoder::decode_json("data_extra_pool", data_extra_pool, obj);
uint32_t it;
JSONDecoder::decode_json("index_type", it, obj);
JSONDecoder::decode_json("inline_data", inline_data, obj);
index_type = (rgw::BucketIndexType)it;
/* backward compatibility, these are now defined in storage_classes */
string standard_compression_type;
string *pcompression = nullptr;
if (JSONDecoder::decode_json("compression", standard_compression_type, obj)) {
pcompression = &standard_compression_type;
}
rgw_pool standard_data_pool;
rgw_pool *ppool = nullptr;
if (JSONDecoder::decode_json("data_pool", standard_data_pool, obj)) {
ppool = &standard_data_pool;
}
if (ppool || pcompression) {
storage_classes.set_storage_class(RGW_STORAGE_CLASS_STANDARD, ppool, pcompression);
}
}
void RGWSystemMetaObj::dump(Formatter *f) const
{
encode_json("id", id , f);
encode_json("name", name , f);
}
void RGWSystemMetaObj::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("id", id, obj);
JSONDecoder::decode_json("name", name, obj);
}
int RGWSystemMetaObj::read_default(const DoutPrefixProvider *dpp,
RGWDefaultSystemMetaObjInfo& default_info,
const string& oid, optional_yield y)
{
using ceph::decode;
auto pool = get_pool(cct);
bufferlist bl;
auto sysobj = sysobj_svc->get_obj(rgw_raw_obj(pool, oid));
int ret = sysobj.rop().read(dpp, &bl, y);
if (ret < 0)
return ret;
try {
auto iter = bl.cbegin();
decode(default_info, iter);
} catch (buffer::error& err) {
ldpp_dout(dpp, 0) << "error decoding data from " << pool << ":" << oid << dendl;
return -EIO;
}
return 0;
}
void RGWZoneGroupPlacementTarget::dump(Formatter *f) const
{
encode_json("name", name, f);
encode_json("tags", tags, f);
encode_json("storage_classes", storage_classes, f);
if (!tier_targets.empty()) {
encode_json("tier_targets", tier_targets, f);
}
}
void RGWZoneGroupPlacementTier::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("tier_type", tier_type, obj);
JSONDecoder::decode_json("storage_class", storage_class, obj);
JSONDecoder::decode_json("retain_head_object", retain_head_object, obj);
if (tier_type == "cloud-s3") {
JSONDecoder::decode_json("s3", t.s3, obj);
}
}
void RGWZoneStorageClasses::dump(Formatter *f) const
{
for (auto& i : m) {
encode_json(i.first.c_str(), i.second, f);
}
}
void RGWZoneStorageClasses::decode_json(JSONObj *obj)
{
JSONFormattable f;
decode_json_obj(f, obj);
for (auto& field : f.object()) {
JSONObj *field_obj = obj->find_obj(field.first);
assert(field_obj);
decode_json_obj(m[field.first], field_obj);
}
standard_class = &m[RGW_STORAGE_CLASS_STANDARD];
}
void RGWZoneGroupPlacementTier::dump(Formatter *f) const
{
encode_json("tier_type", tier_type, f);
encode_json("storage_class", storage_class, f);
encode_json("retain_head_object", retain_head_object, f);
if (tier_type == "cloud-s3") {
encode_json("s3", t.s3, f);
}
}
void RGWZoneGroupPlacementTierS3::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("endpoint", endpoint, obj);
JSONDecoder::decode_json("access_key", key.id, obj);
JSONDecoder::decode_json("secret", key.key, obj);
JSONDecoder::decode_json("region", region, obj);
string s;
JSONDecoder::decode_json("host_style", s, obj);
if (s != "virtual") {
host_style = PathStyle;
} else {
host_style = VirtualStyle;
}
JSONDecoder::decode_json("target_storage_class", target_storage_class, obj);
JSONDecoder::decode_json("target_path", target_path, obj);
JSONDecoder::decode_json("acl_mappings", acl_mappings, obj);
JSONDecoder::decode_json("multipart_sync_threshold", multipart_sync_threshold, obj);
JSONDecoder::decode_json("multipart_min_part_size", multipart_min_part_size, obj);
}
void RGWZoneStorageClass::dump(Formatter *f) const
{
if (data_pool) {
encode_json("data_pool", data_pool.get(), f);
}
if (compression_type) {
encode_json("compression_type", compression_type.get(), f);
}
}
void RGWZoneStorageClass::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("data_pool", data_pool, obj);
JSONDecoder::decode_json("compression_type", compression_type, obj);
}
void RGWTierACLMapping::decode_json(JSONObj *obj)
{
string s;
JSONDecoder::decode_json("type", s, obj);
if (s == "email") {
type = ACL_TYPE_EMAIL_USER;
} else if (s == "uri") {
type = ACL_TYPE_GROUP;
} else {
type = ACL_TYPE_CANON_USER;
}
JSONDecoder::decode_json("source_id", source_id, obj);
JSONDecoder::decode_json("dest_id", dest_id, obj);
}
void RGWZoneGroupPlacementTierS3::dump(Formatter *f) const
{
encode_json("endpoint", endpoint, f);
encode_json("access_key", key.id, f);
encode_json("secret", key.key, f);
encode_json("region", region, f);
string s = (host_style == PathStyle ? "path" : "virtual");
encode_json("host_style", s, f);
encode_json("target_storage_class", target_storage_class, f);
encode_json("target_path", target_path, f);
encode_json("acl_mappings", acl_mappings, f);
encode_json("multipart_sync_threshold", multipart_sync_threshold, f);
encode_json("multipart_min_part_size", multipart_min_part_size, f);
}
void RGWTierACLMapping::dump(Formatter *f) const
{
string s;
switch (type) {
case ACL_TYPE_EMAIL_USER:
s = "email";
break;
case ACL_TYPE_GROUP:
s = "uri";
break;
default:
s = "id";
break;
}
encode_json("type", s, f);
encode_json("source_id", source_id, f);
encode_json("dest_id", dest_id, f);
}
void RGWPeriodMap::dump(Formatter *f) const
{
encode_json("id", id, f);
encode_json_map("zonegroups", zonegroups, f);
encode_json("short_zone_ids", short_zone_ids, f);
}
static void decode_zonegroups(map<string, RGWZoneGroup>& zonegroups, JSONObj *o)
{
RGWZoneGroup zg;
zg.decode_json(o);
zonegroups[zg.get_id()] = zg;
}
void RGWPeriodMap::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("id", id, obj);
JSONDecoder::decode_json("zonegroups", zonegroups, decode_zonegroups, obj);
/* backward compatability with region */
if (zonegroups.empty()) {
JSONDecoder::decode_json("regions", zonegroups, obj);
}
/* backward compatability with region */
if (master_zonegroup.empty()) {
JSONDecoder::decode_json("master_region", master_zonegroup, obj);
}
JSONDecoder::decode_json("short_zone_ids", short_zone_ids, obj);
}
void RGWPeriodMap::decode(bufferlist::const_iterator& bl) {
DECODE_START(2, bl);
decode(id, bl);
decode(zonegroups, bl);
decode(master_zonegroup, bl);
if (struct_v >= 2) {
decode(short_zone_ids, bl);
}
DECODE_FINISH(bl);
zonegroups_by_api.clear();
for (map<string, RGWZoneGroup>::iterator iter = zonegroups.begin();
iter != zonegroups.end(); ++iter) {
RGWZoneGroup& zonegroup = iter->second;
zonegroups_by_api[zonegroup.api_name] = zonegroup;
if (zonegroup.is_master_zonegroup()) {
master_zonegroup = zonegroup.get_id();
}
}
}
void RGWPeriodMap::encode(bufferlist& bl) const
{
ENCODE_START(2, 1, bl);
encode(id, bl);
encode(zonegroups, bl);
encode(master_zonegroup, bl);
encode(short_zone_ids, bl);
ENCODE_FINISH(bl);
}
int RGWSystemMetaObj::create(const DoutPrefixProvider *dpp, optional_yield y, bool exclusive)
{
int ret;
/* check to see the name is not used */
ret = read_id(dpp, name, id, y);
if (exclusive && ret == 0) {
ldpp_dout(dpp, 10) << "ERROR: name " << name << " already in use for obj id " << id << dendl;
return -EEXIST;
} else if ( ret < 0 && ret != -ENOENT) {
ldpp_dout(dpp, 0) << "failed reading obj id " << id << ": " << cpp_strerror(-ret) << dendl;
return ret;
}
if (id.empty()) {
/* create unique id */
uuid_d new_uuid;
char uuid_str[37];
new_uuid.generate_random();
new_uuid.print(uuid_str);
id = uuid_str;
}
ret = store_info(dpp, exclusive, y);
if (ret < 0) {
ldpp_dout(dpp, 0) << "ERROR: storing info for " << id << ": " << cpp_strerror(-ret) << dendl;
return ret;
}
return store_name(dpp, exclusive, y);
}
int RGWSystemMetaObj::read_default_id(const DoutPrefixProvider *dpp, string& default_id, optional_yield y,
bool old_format)
{
RGWDefaultSystemMetaObjInfo default_info;
int ret = read_default(dpp, default_info, get_default_oid(old_format), y);
if (ret < 0) {
return ret;
}
default_id = default_info.default_id;
return 0;
}
int RGWSystemMetaObj::set_as_default(const DoutPrefixProvider *dpp, optional_yield y, bool exclusive)
{
using ceph::encode;
string oid = get_default_oid();
rgw_pool pool(get_pool(cct));
bufferlist bl;
RGWDefaultSystemMetaObjInfo default_info;
default_info.default_id = id;
encode(default_info, bl);
auto sysobj = sysobj_svc->get_obj(rgw_raw_obj(pool, oid));
int ret = sysobj.wop()
.set_exclusive(exclusive)
.write(dpp, bl, y);
if (ret < 0)
return ret;
return 0;
}
int RGWSystemMetaObj::store_info(const DoutPrefixProvider *dpp, bool exclusive, optional_yield y)
{
rgw_pool pool(get_pool(cct));
string oid = get_info_oid_prefix() + id;
bufferlist bl;
using ceph::encode;
encode(*this, bl);
auto sysobj = sysobj_svc->get_obj(rgw_raw_obj{pool, oid});
return sysobj.wop()
.set_exclusive(exclusive)
.write(dpp, bl, y);
}
int RGWSystemMetaObj::read_id(const DoutPrefixProvider *dpp, const string& obj_name, string& object_id,
optional_yield y)
{
using ceph::decode;
rgw_pool pool(get_pool(cct));
bufferlist bl;
string oid = get_names_oid_prefix() + obj_name;
auto sysobj = sysobj_svc->get_obj(rgw_raw_obj(pool, oid));
int ret = sysobj.rop().read(dpp, &bl, y);
if (ret < 0) {
return ret;
}
RGWNameToId nameToId;
try {
auto iter = bl.cbegin();
decode(nameToId, iter);
} catch (buffer::error& err) {
ldpp_dout(dpp, 0) << "ERROR: failed to decode obj from " << pool << ":" << oid << dendl;
return -EIO;
}
object_id = nameToId.obj_id;
return 0;
}
int RGWSystemMetaObj::store_name(const DoutPrefixProvider *dpp, bool exclusive, optional_yield y)
{
rgw_pool pool(get_pool(cct));
string oid = get_names_oid_prefix() + name;
RGWNameToId nameToId;
nameToId.obj_id = id;
bufferlist bl;
using ceph::encode;
encode(nameToId, bl);
auto sysobj = sysobj_svc->get_obj(rgw_raw_obj(pool, oid));
return sysobj.wop()
.set_exclusive(exclusive)
.write(dpp, bl, y);
}
bool RGWPeriodMap::find_zone_by_id(const rgw_zone_id& zone_id,
RGWZoneGroup *zonegroup,
RGWZone *zone) const
{
for (auto& iter : zonegroups) {
auto& zg = iter.second;
auto ziter = zg.zones.find(zone_id);
if (ziter != zg.zones.end()) {
*zonegroup = zg;
*zone = ziter->second;
return true;
}
}
return false;
}
int RGWZoneGroup::set_as_default(const DoutPrefixProvider *dpp, optional_yield y, bool exclusive)
{
if (realm_id.empty()) {
/* try using default realm */
RGWRealm realm;
int ret = realm.init(dpp, cct, sysobj_svc, y);
if (ret < 0) {
ldpp_dout(dpp, 10) << "could not read realm id: " << cpp_strerror(-ret) << dendl;
return -EINVAL;
}
realm_id = realm.get_id();
}
return RGWSystemMetaObj::set_as_default(dpp, y, exclusive);
}
int RGWSystemMetaObj::write(const DoutPrefixProvider *dpp, bool exclusive, optional_yield y)
{
int ret = store_info(dpp, exclusive, y);
if (ret < 0) {
ldpp_dout(dpp, 20) << __func__ << "(): store_info() returned ret=" << ret << dendl;
return ret;
}
ret = store_name(dpp, exclusive, y);
if (ret < 0) {
ldpp_dout(dpp, 20) << __func__ << "(): store_name() returned ret=" << ret << dendl;
return ret;
}
return 0;
}
namespace rgw {
int init_zone_pool_names(const DoutPrefixProvider *dpp, optional_yield y,
const std::set<rgw_pool>& pools, RGWZoneParams& info)
{
info.domain_root = fix_zone_pool_dup(pools, info.name, ".rgw.meta:root", info.domain_root);
info.control_pool = fix_zone_pool_dup(pools, info.name, ".rgw.control", info.control_pool);
info.gc_pool = fix_zone_pool_dup(pools, info.name, ".rgw.log:gc", info.gc_pool);
info.lc_pool = fix_zone_pool_dup(pools, info.name, ".rgw.log:lc", info.lc_pool);
info.log_pool = fix_zone_pool_dup(pools, info.name, ".rgw.log", info.log_pool);
info.intent_log_pool = fix_zone_pool_dup(pools, info.name, ".rgw.log:intent", info.intent_log_pool);
info.usage_log_pool = fix_zone_pool_dup(pools, info.name, ".rgw.log:usage", info.usage_log_pool);
info.user_keys_pool = fix_zone_pool_dup(pools, info.name, ".rgw.meta:users.keys", info.user_keys_pool);
info.user_email_pool = fix_zone_pool_dup(pools, info.name, ".rgw.meta:users.email", info.user_email_pool);
info.user_swift_pool = fix_zone_pool_dup(pools, info.name, ".rgw.meta:users.swift", info.user_swift_pool);
info.user_uid_pool = fix_zone_pool_dup(pools, info.name, ".rgw.meta:users.uid", info.user_uid_pool);
info.roles_pool = fix_zone_pool_dup(pools, info.name, ".rgw.meta:roles", info.roles_pool);
info.reshard_pool = fix_zone_pool_dup(pools, info.name, ".rgw.log:reshard", info.reshard_pool);
info.otp_pool = fix_zone_pool_dup(pools, info.name, ".rgw.otp", info.otp_pool);
info.oidc_pool = fix_zone_pool_dup(pools, info.name, ".rgw.meta:oidc", info.oidc_pool);
info.notif_pool = fix_zone_pool_dup(pools, info.name, ".rgw.log:notif", info.notif_pool);
for (auto& [pname, placement] : info.placement_pools) {
placement.index_pool = fix_zone_pool_dup(pools, info.name, "." + default_bucket_index_pool_suffix, placement.index_pool);
placement.data_extra_pool= fix_zone_pool_dup(pools, info.name, "." + default_storage_extra_pool_suffix, placement.data_extra_pool);
for (auto& [sname, sc] : placement.storage_classes.get_all()) {
if (sc.data_pool) {
sc.data_pool = fix_zone_pool_dup(pools, info.name, "." + default_storage_pool_suffix, *sc.data_pool);
}
}
}
return 0;
}
int add_zone_to_group(const DoutPrefixProvider* dpp, RGWZoneGroup& zonegroup,
const RGWZoneParams& zone_params,
const bool *pis_master, const bool *pread_only,
const std::list<std::string>& endpoints,
const std::string *ptier_type,
const bool *psync_from_all,
const std::list<std::string>& sync_from,
const std::list<std::string>& sync_from_rm,
const std::string *predirect_zone,
std::optional<int> bucket_index_max_shards,
const rgw::zone_features::set& enable_features,
const rgw::zone_features::set& disable_features)
{
const std::string& zone_id = zone_params.id;
const std::string& zone_name = zone_params.name;
if (zone_id.empty()) {
ldpp_dout(dpp, -1) << __func__ << " requires a zone id" << dendl;
return -EINVAL;
}
if (zone_name.empty()) {
ldpp_dout(dpp, -1) << __func__ << " requires a zone name" << dendl;
return -EINVAL;
}
// check for duplicate zone name on insert
if (!zonegroup.zones.count(zone_id)) {
for (const auto& [id, zone] : zonegroup.zones) {
if (zone.name == zone_name) {
ldpp_dout(dpp, 0) << "ERROR: found existing zone name " << zone_name
<< " (" << id << ") in zonegroup " << zonegroup.name << dendl;
return -EEXIST;
}
}
}
rgw_zone_id& master_zone = zonegroup.master_zone;
if (pis_master) {
if (*pis_master) {
if (!master_zone.empty() && master_zone != zone_id) {
ldpp_dout(dpp, 0) << "NOTICE: overriding master zone: "
<< master_zone << dendl;
}
master_zone = zone_id;
} else if (master_zone == zone_id) {
master_zone.clear();
}
} else if (master_zone.empty() && zonegroup.zones.empty()) {
ldpp_dout(dpp, 0) << "NOTICE: promoted " << zone_name
<< " as new master_zone of zonegroup " << zonegroup.name << dendl;
master_zone = zone_id;
}
// make sure the zone's placement targets are named in the zonegroup
for (const auto& [name, placement] : zone_params.placement_pools) {
auto target = RGWZoneGroupPlacementTarget{.name = name};
zonegroup.placement_targets.emplace(name, std::move(target));
}
RGWZone& zone = zonegroup.zones[zone_params.id];
zone.id = zone_params.id;
zone.name = zone_params.name;
if (!endpoints.empty()) {
zone.endpoints = endpoints;
}
if (pread_only) {
zone.read_only = *pread_only;
}
if (ptier_type) {
zone.tier_type = *ptier_type;
}
if (psync_from_all) {
zone.sync_from_all = *psync_from_all;
}
if (predirect_zone) {
zone.redirect_zone = *predirect_zone;
}
if (bucket_index_max_shards) {
zone.bucket_index_max_shards = *bucket_index_max_shards;
}
// add/remove sync_from
for (auto add : sync_from) {
zone.sync_from.insert(add);
}
for (const auto& rm : sync_from_rm) {
auto i = zone.sync_from.find(rm);
if (i == zone.sync_from.end()) {
ldpp_dout(dpp, 1) << "WARNING: zone \"" << rm
<< "\" was not in sync_from" << dendl;
continue;
}
zone.sync_from.erase(i);
}
// add/remove supported features
zone.supported_features.insert(enable_features.begin(),
enable_features.end());
for (const auto& feature : disable_features) {
if (zonegroup.enabled_features.contains(feature)) {
ldpp_dout(dpp, -1) << "ERROR: Cannot disable zone feature \"" << feature
<< "\" until it's been disabled in zonegroup " << zonegroup.name << dendl;
return -EINVAL;
}
auto i = zone.supported_features.find(feature);
if (i == zone.supported_features.end()) {
ldpp_dout(dpp, 1) << "WARNING: zone feature \"" << feature
<< "\" was not enabled in zone " << zone.name << dendl;
continue;
}
zone.supported_features.erase(i);
}
const bool log_data = zonegroup.zones.size() > 1;
for (auto& [id, zone] : zonegroup.zones) {
zone.log_data = log_data;
}
return 0;
}
} // namespace rgw
| 43,436 | 30.659621 | 135 |
cc
|
null |
ceph-main/src/rgw/rgw_zone_features.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/* N.B., this header defines fundamental serialized types. Do not
* include files which can only be compiled in radosgw or OSD
* contexts (e.g., rgw_sal.h, rgw_common.h) */
#pragma once
#include <string>
#include <boost/container/flat_set.hpp>
namespace rgw::zone_features {
// zone feature names
inline constexpr std::string_view resharding = "resharding";
inline constexpr std::string_view compress_encrypted = "compress-encrypted";
// static list of features supported by this release
inline constexpr std::initializer_list<std::string_view> supported = {
resharding,
compress_encrypted,
};
inline constexpr bool supports(std::string_view feature) {
for (auto i : supported) {
if (feature.compare(i) == 0) {
return true;
}
}
return false;
}
// static list of features enabled by default on new zonegroups
inline constexpr std::initializer_list<std::string_view> enabled = {
resharding,
};
// enable string_view overloads for find() contains() etc
struct feature_less : std::less<std::string_view> {
using is_transparent = std::true_type;
};
using set = boost::container::flat_set<std::string, feature_less>;
} // namespace rgw::zone_features
| 1,293 | 25.958333 | 76 |
h
|
null |
ceph-main/src/rgw/rgw_zone_types.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2019 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
/* N.B., this header defines fundamental serialized types. Do not
* introduce changes or include files which can only be compiled in
* radosgw or OSD contexts (e.g., rgw_sal.h, rgw_common.h)
*/
#pragma once
#include <string>
#include <set>
#include <map>
#include <list>
#include <boost/optional.hpp>
#include <fmt/format.h>
#include "include/types.h"
#include "rgw_bucket_layout.h"
#include "rgw_zone_features.h"
#include "rgw_pool_types.h"
#include "rgw_acl_types.h"
#include "rgw_placement_types.h"
#include "common/Formatter.h"
class JSONObj;
namespace rgw_zone_defaults {
extern std::string zone_names_oid_prefix;
extern std::string region_info_oid_prefix;
extern std::string realm_names_oid_prefix;
extern std::string zone_group_info_oid_prefix;
extern std::string realm_info_oid_prefix;
extern std::string default_region_info_oid;
extern std::string default_zone_group_info_oid;
extern std::string region_map_oid;
extern std::string default_realm_info_oid;
extern std::string default_zonegroup_name;
extern std::string default_zone_name;
extern std::string zonegroup_names_oid_prefix;
extern std::string RGW_DEFAULT_ZONE_ROOT_POOL;
extern std::string RGW_DEFAULT_ZONEGROUP_ROOT_POOL;
extern std::string RGW_DEFAULT_REALM_ROOT_POOL;
extern std::string RGW_DEFAULT_PERIOD_ROOT_POOL;
extern std::string avail_pools;
extern std::string default_storage_pool_suffix;
} /* namespace rgw_zone_defaults */
struct RGWNameToId {
std::string obj_id;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(obj_id, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(obj_id, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
};
WRITE_CLASS_ENCODER(RGWNameToId)
struct RGWDefaultSystemMetaObjInfo {
std::string default_id;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(default_id, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(default_id, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
};
WRITE_CLASS_ENCODER(RGWDefaultSystemMetaObjInfo)
struct RGWZoneStorageClass {
boost::optional<rgw_pool> data_pool;
boost::optional<std::string> compression_type;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(data_pool, bl);
encode(compression_type, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(data_pool, bl);
decode(compression_type, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
};
WRITE_CLASS_ENCODER(RGWZoneStorageClass)
class RGWZoneStorageClasses {
std::map<std::string, RGWZoneStorageClass> m;
/* in memory only */
RGWZoneStorageClass *standard_class;
public:
RGWZoneStorageClasses() {
standard_class = &m[RGW_STORAGE_CLASS_STANDARD];
}
RGWZoneStorageClasses(const RGWZoneStorageClasses& rhs) {
m = rhs.m;
standard_class = &m[RGW_STORAGE_CLASS_STANDARD];
}
RGWZoneStorageClasses& operator=(const RGWZoneStorageClasses& rhs) {
m = rhs.m;
standard_class = &m[RGW_STORAGE_CLASS_STANDARD];
return *this;
}
const RGWZoneStorageClass& get_standard() const {
return *standard_class;
}
bool find(const std::string& sc, const RGWZoneStorageClass** pstorage_class) const {
auto iter = m.find(sc);
if (iter == m.end()) {
return false;
}
*pstorage_class = &iter->second;
return true;
}
bool exists(const std::string& sc) const {
if (sc.empty()) {
return true;
}
auto iter = m.find(sc);
return (iter != m.end());
}
const std::map<std::string, RGWZoneStorageClass>& get_all() const {
return m;
}
std::map<std::string, RGWZoneStorageClass>& get_all() {
return m;
}
void set_storage_class(const std::string& sc, const rgw_pool* data_pool, const std::string* compression_type) {
const std::string *psc = ≻
if (sc.empty()) {
psc = &RGW_STORAGE_CLASS_STANDARD;
}
RGWZoneStorageClass& storage_class = m[*psc];
if (data_pool) {
storage_class.data_pool = *data_pool;
}
if (compression_type) {
storage_class.compression_type = *compression_type;
}
}
void remove_storage_class(const std::string& sc) {
if (!sc.empty()) {
m.erase(sc);
}
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(m, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(m, bl);
standard_class = &m[RGW_STORAGE_CLASS_STANDARD];
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
};
WRITE_CLASS_ENCODER(RGWZoneStorageClasses)
struct RGWZonePlacementInfo {
rgw_pool index_pool;
rgw_pool data_extra_pool; /* if not set we should use data_pool */
RGWZoneStorageClasses storage_classes;
rgw::BucketIndexType index_type;
bool inline_data;
RGWZonePlacementInfo() : index_type(rgw::BucketIndexType::Normal), inline_data(true) {}
void encode(bufferlist& bl) const {
ENCODE_START(8, 1, bl);
encode(index_pool.to_str(), bl);
rgw_pool standard_data_pool = get_data_pool(RGW_STORAGE_CLASS_STANDARD);
encode(standard_data_pool.to_str(), bl);
encode(data_extra_pool.to_str(), bl);
encode((uint32_t)index_type, bl);
std::string standard_compression_type = get_compression_type(RGW_STORAGE_CLASS_STANDARD);
encode(standard_compression_type, bl);
encode(storage_classes, bl);
encode(inline_data, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(8, bl);
std::string index_pool_str;
std::string data_pool_str;
decode(index_pool_str, bl);
index_pool = rgw_pool(index_pool_str);
decode(data_pool_str, bl);
rgw_pool standard_data_pool(data_pool_str);
if (struct_v >= 4) {
std::string data_extra_pool_str;
decode(data_extra_pool_str, bl);
data_extra_pool = rgw_pool(data_extra_pool_str);
}
if (struct_v >= 5) {
uint32_t it;
decode(it, bl);
index_type = (rgw::BucketIndexType)it;
}
std::string standard_compression_type;
if (struct_v >= 6) {
decode(standard_compression_type, bl);
}
if (struct_v >= 7) {
decode(storage_classes, bl);
} else {
storage_classes.set_storage_class(RGW_STORAGE_CLASS_STANDARD, &standard_data_pool,
(!standard_compression_type.empty() ? &standard_compression_type : nullptr));
}
if (struct_v >= 8) {
decode(inline_data, bl);
}
DECODE_FINISH(bl);
}
const rgw_pool& get_data_extra_pool() const {
static rgw_pool no_pool;
if (data_extra_pool.empty()) {
return storage_classes.get_standard().data_pool.get_value_or(no_pool);
}
return data_extra_pool;
}
const rgw_pool& get_data_pool(const std::string& sc) const {
const RGWZoneStorageClass *storage_class;
static rgw_pool no_pool;
if (!storage_classes.find(sc, &storage_class)) {
return storage_classes.get_standard().data_pool.get_value_or(no_pool);
}
return storage_class->data_pool.get_value_or(no_pool);
}
const rgw_pool& get_standard_data_pool() const {
return get_data_pool(RGW_STORAGE_CLASS_STANDARD);
}
const std::string& get_compression_type(const std::string& sc) const {
const RGWZoneStorageClass *storage_class;
static std::string no_compression;
if (!storage_classes.find(sc, &storage_class)) {
return no_compression;
}
return storage_class->compression_type.get_value_or(no_compression);
}
bool storage_class_exists(const std::string& sc) const {
return storage_classes.exists(sc);
}
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
};
WRITE_CLASS_ENCODER(RGWZonePlacementInfo)
struct RGWZone {
std::string id;
std::string name;
std::list<std::string> endpoints; // std::vector?
bool log_meta;
bool log_data;
bool read_only;
std::string tier_type;
std::string redirect_zone;
/**
* Represents the number of shards for the bucket index object, a value of zero
* indicates there is no sharding. By default (no sharding, the name of the object
* is '.dir.{marker}', with sharding, the name is '.dir.{marker}.{sharding_id}',
* sharding_id is zero-based value. It is not recommended to set a too large value
* (e.g. thousand) as it increases the cost for bucket listing.
*/
uint32_t bucket_index_max_shards;
// pre-shard buckets on creation to enable some write-parallism by default,
// delay the need to reshard as the bucket grows, and (in multisite) get some
// bucket index sharding where dynamic resharding is not supported
static constexpr uint32_t default_bucket_index_max_shards = 11;
bool sync_from_all;
std::set<std::string> sync_from; /* list of zones to sync from */
rgw::zone_features::set supported_features;
RGWZone()
: log_meta(false), log_data(false), read_only(false),
bucket_index_max_shards(default_bucket_index_max_shards),
sync_from_all(true) {}
void encode(bufferlist& bl) const {
ENCODE_START(8, 1, bl);
encode(name, bl);
encode(endpoints, bl);
encode(log_meta, bl);
encode(log_data, bl);
encode(bucket_index_max_shards, bl);
encode(id, bl);
encode(read_only, bl);
encode(tier_type, bl);
encode(sync_from_all, bl);
encode(sync_from, bl);
encode(redirect_zone, bl);
encode(supported_features, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(8, bl);
decode(name, bl);
if (struct_v < 4) {
id = name;
}
decode(endpoints, bl);
if (struct_v >= 2) {
decode(log_meta, bl);
decode(log_data, bl);
}
if (struct_v >= 3) {
decode(bucket_index_max_shards, bl);
}
if (struct_v >= 4) {
decode(id, bl);
decode(read_only, bl);
}
if (struct_v >= 5) {
decode(tier_type, bl);
}
if (struct_v >= 6) {
decode(sync_from_all, bl);
decode(sync_from, bl);
}
if (struct_v >= 7) {
decode(redirect_zone, bl);
}
if (struct_v >= 8) {
decode(supported_features, bl);
}
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
static void generate_test_instances(std::list<RGWZone*>& o);
bool is_read_only() const { return read_only; }
bool syncs_from(const std::string& zone_name) const {
return (sync_from_all || sync_from.find(zone_name) != sync_from.end());
}
bool supports(std::string_view feature) const {
return supported_features.contains(feature);
}
};
WRITE_CLASS_ENCODER(RGWZone)
struct RGWDefaultZoneGroupInfo {
std::string default_zonegroup;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(default_zonegroup, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(default_zonegroup, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
//todo: implement ceph-dencoder
};
WRITE_CLASS_ENCODER(RGWDefaultZoneGroupInfo)
struct RGWTierACLMapping {
ACLGranteeTypeEnum type{ACL_TYPE_CANON_USER};
std::string source_id;
std::string dest_id;
RGWTierACLMapping() = default;
RGWTierACLMapping(ACLGranteeTypeEnum t,
const std::string& s,
const std::string& d) : type(t),
source_id(s),
dest_id(d) {}
void init(const JSONFormattable& config) {
const std::string& t = config["type"];
if (t == "email") {
type = ACL_TYPE_EMAIL_USER;
} else if (t == "uri") {
type = ACL_TYPE_GROUP;
} else {
type = ACL_TYPE_CANON_USER;
}
source_id = config["source_id"];
dest_id = config["dest_id"];
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode((uint32_t)type, bl);
encode(source_id, bl);
encode(dest_id, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
uint32_t it;
decode(it, bl);
type = (ACLGranteeTypeEnum)it;
decode(source_id, bl);
decode(dest_id, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
};
WRITE_CLASS_ENCODER(RGWTierACLMapping)
enum HostStyle {
PathStyle = 0,
VirtualStyle = 1,
};
struct RGWZoneGroupPlacementTierS3 {
#define DEFAULT_MULTIPART_SYNC_PART_SIZE (32 * 1024 * 1024)
std::string endpoint;
RGWAccessKey key;
std::string region;
HostStyle host_style{PathStyle};
std::string target_storage_class;
/* Should below be bucket/zone specific?? */
std::string target_path;
std::map<std::string, RGWTierACLMapping> acl_mappings;
uint64_t multipart_sync_threshold{DEFAULT_MULTIPART_SYNC_PART_SIZE};
uint64_t multipart_min_part_size{DEFAULT_MULTIPART_SYNC_PART_SIZE};
int update_params(const JSONFormattable& config);
int clear_params(const JSONFormattable& config);
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(endpoint, bl);
encode(key, bl);
encode(region, bl);
encode((uint32_t)host_style, bl); // XXX kill C-style casts
encode(target_storage_class, bl);
encode(target_path, bl);
encode(acl_mappings, bl);
encode(multipart_sync_threshold, bl);
encode(multipart_min_part_size, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(endpoint, bl);
decode(key, bl);
decode(region, bl);
uint32_t it;
decode(it, bl);
host_style = (HostStyle)it; // XXX can't this be HostStyle(it)?
decode(target_storage_class, bl);
decode(target_path, bl);
decode(acl_mappings, bl);
decode(multipart_sync_threshold, bl);
decode(multipart_min_part_size, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
};
WRITE_CLASS_ENCODER(RGWZoneGroupPlacementTierS3)
struct RGWZoneGroupPlacementTier {
std::string tier_type;
std::string storage_class;
bool retain_head_object = false;
struct _tier {
RGWZoneGroupPlacementTierS3 s3;
} t;
int update_params(const JSONFormattable& config);
int clear_params(const JSONFormattable& config);
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(tier_type, bl);
encode(storage_class, bl);
encode(retain_head_object, bl);
if (tier_type == "cloud-s3") {
encode(t.s3, bl);
}
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(tier_type, bl);
decode(storage_class, bl);
decode(retain_head_object, bl);
if (tier_type == "cloud-s3") {
decode(t.s3, bl);
}
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
};
WRITE_CLASS_ENCODER(RGWZoneGroupPlacementTier)
struct RGWZoneGroupPlacementTarget {
std::string name;
std::set<std::string> tags;
std::set<std::string> storage_classes;
std::map<std::string, RGWZoneGroupPlacementTier> tier_targets;
bool user_permitted(const std::list<std::string>& user_tags) const {
if (tags.empty()) {
return true;
}
for (auto& rule : user_tags) {
if (tags.find(rule) != tags.end()) {
return true;
}
}
return false;
}
void encode(bufferlist& bl) const {
ENCODE_START(3, 1, bl);
encode(name, bl);
encode(tags, bl);
encode(storage_classes, bl);
encode(tier_targets, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(3, bl);
decode(name, bl);
decode(tags, bl);
if (struct_v >= 2) {
decode(storage_classes, bl);
}
if (storage_classes.empty()) {
storage_classes.insert(RGW_STORAGE_CLASS_STANDARD);
}
if (struct_v >= 3) {
decode(tier_targets, bl);
}
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
};
WRITE_CLASS_ENCODER(RGWZoneGroupPlacementTarget)
| 16,654 | 25.605431 | 117 |
h
|
null |
ceph-main/src/rgw/driver/d4n/d4n_datacache.cc
|
#include "d4n_datacache.h"
#define dout_subsys ceph_subsys_rgw
#define dout_context g_ceph_context
/* Base metadata and data fields should remain consistent */
std::vector<std::string> baseFields {
"mtime",
"object_size",
"accounted_size",
"epoch",
"version_id",
"source_zone_short_id",
"bucket_count",
"bucket_size",
"user_quota.max_size",
"user_quota.max_objects",
"max_buckets",
"data"};
std::vector< std::pair<std::string, std::string> > RGWD4NCache::buildObject(rgw::sal::Attrs* binary) {
std::vector< std::pair<std::string, std::string> > values;
rgw::sal::Attrs::iterator attrs;
/* Convert to vector */
if (binary != NULL) {
for (attrs = binary->begin(); attrs != binary->end(); ++attrs) {
values.push_back(std::make_pair(attrs->first, attrs->second.to_str()));
}
}
return values;
}
int RGWD4NCache::findClient(cpp_redis::client *client) {
if (client->is_connected())
return 0;
if (host == "" || port == 0) {
dout(10) << "RGW D4N Cache: D4N cache endpoint was not configured correctly" << dendl;
return EDESTADDRREQ;
}
client->connect(host, port, nullptr);
if (!client->is_connected())
return ECONNREFUSED;
return 0;
}
int RGWD4NCache::existKey(std::string key) {
int result = -1;
std::vector<std::string> keys;
keys.push_back(key);
if (!client.is_connected()) {
return result;
}
try {
client.exists(keys, [&result](cpp_redis::reply &reply) {
if (reply.is_integer()) {
result = reply.as_integer(); /* Returns 1 upon success */
}
});
client.sync_commit(std::chrono::milliseconds(1000));
} catch(std::exception &e) {}
return result;
}
int RGWD4NCache::setObject(std::string oid, rgw::sal::Attrs* attrs) {
/* Creating the index based on oid */
std::string key = "rgw-object:" + oid + ":cache";
std::string result;
if (!client.is_connected()) {
findClient(&client);
}
/* Every set will be treated as new */
try {
std::vector< std::pair<std::string, std::string> > redisObject = buildObject(attrs);
if (redisObject.empty()) {
return -1;
}
client.hmset(key, redisObject, [&result](cpp_redis::reply &reply) {
if (!reply.is_null()) {
result = reply.as_string();
}
});
client.sync_commit(std::chrono::milliseconds(1000));
if (result != "OK") {
return -1;
}
} catch(std::exception &e) {
return -1;
}
return 0;
}
int RGWD4NCache::getObject(std::string oid,
rgw::sal::Attrs* newAttrs,
std::vector< std::pair<std::string, std::string> >* newMetadata)
{
std::string result;
std::string key = "rgw-object:" + oid + ":cache";
if (!client.is_connected()) {
findClient(&client);
}
if (existKey(key)) {
int field_exist = -1;
rgw::sal::Attrs::iterator it;
std::vector< std::pair<std::string, std::string> > redisObject;
std::vector<std::string> getFields;
/* Retrieve existing fields from cache */
try {
client.hgetall(key, [&getFields](cpp_redis::reply &reply) {
if (reply.is_array()) {
auto arr = reply.as_array();
if (!arr[0].is_null()) {
for (long unsigned int i = 0; i < arr.size() - 1; i += 2) {
getFields.push_back(arr[i].as_string());
}
}
}
});
client.sync_commit(std::chrono::milliseconds(1000));
} catch(std::exception &e) {
return -1;
}
/* Only data exists */
if (getFields.size() == 1 && getFields[0] == "data")
return 0;
/* Ensure all metadata, attributes, and data has been set */
for (const auto& field : baseFields) {
auto it = std::find_if(getFields.begin(), getFields.end(),
[&](const auto& comp) { return comp == field; });
if (it != getFields.end()) {
int index = std::distance(getFields.begin(), it);
getFields.erase(getFields.begin() + index);
} else {
return -1;
}
}
/* Get attributes from cache */
try {
client.hmget(key, getFields, [&field_exist, &newAttrs, &getFields](cpp_redis::reply &reply) {
if (reply.is_array()) {
auto arr = reply.as_array();
if (!arr[0].is_null()) {
field_exist = 0;
for (long unsigned int i = 0; i < getFields.size(); ++i) {
std::string tmp = arr[i].as_string();
buffer::list bl;
bl.append(tmp);
newAttrs->insert({getFields[i], bl});
}
}
}
});
client.sync_commit(std::chrono::milliseconds(1000));
} catch(std::exception &e) {
return -1;
}
if (field_exist == 0) {
field_exist = -1;
getFields.clear();
getFields.insert(getFields.begin(), baseFields.begin(), baseFields.end());
getFields.pop_back(); /* Do not query for data field */
/* Get metadata from cache */
try {
client.hmget(key, getFields, [&field_exist, &newMetadata, &getFields](cpp_redis::reply &reply) {
if (reply.is_array()) {
auto arr = reply.as_array();
if (!arr[0].is_null()) {
field_exist = 0;
for (long unsigned int i = 0; i < getFields.size(); ++i) {
newMetadata->push_back({getFields[i], arr[i].as_string()});
}
}
}
});
client.sync_commit(std::chrono::milliseconds(1000));
} catch(std::exception &e) {
return -1;
}
} else {
return -1;
}
} else {
dout(20) << "RGW D4N Cache: Object was not retrievable." << dendl;
return -2;
}
return 0;
}
int RGWD4NCache::copyObject(std::string original_oid, std::string copy_oid, rgw::sal::Attrs* attrs) {
std::string result;
std::vector< std::pair<std::string, std::string> > redisObject;
std::string key = "rgw-object:" + original_oid + ":cache";
if (!client.is_connected()) {
findClient(&client);
}
/* Read values from cache */
if (existKey(key)) {
try {
client.hgetall(key, [&redisObject](cpp_redis::reply &reply) {
if (reply.is_array()) {
auto arr = reply.as_array();
if (!arr[0].is_null()) {
for (long unsigned int i = 0; i < arr.size() - 1; i += 2) {
redisObject.push_back({arr[i].as_string(), arr[i + 1].as_string()});
}
}
}
});
client.sync_commit(std::chrono::milliseconds(1000));
} catch(std::exception &e) {
return -1;
}
} else {
return -2;
}
/* Build copy with updated values */
if (!redisObject.empty()) {
rgw::sal::Attrs::iterator attr;
for (attr = attrs->begin(); attr != attrs->end(); ++attr) {
auto it = std::find_if(redisObject.begin(), redisObject.end(),
[&](const auto& pair) { return pair.first == attr->first; });
if (it != redisObject.end()) {
int index = std::distance(redisObject.begin(), it);
redisObject[index] = {attr->first, attr->second.to_str()};
} else {
redisObject.push_back(std::make_pair(attr->first, attr->second.to_str()));
}
}
} else {
return -1;
}
/* Set copy with new values */
key = "rgw-object:" + copy_oid + ":cache";
try {
client.hmset(key, redisObject, [&result](cpp_redis::reply &reply) {
if (!reply.is_null()) {
result = reply.as_string();
}
});
client.sync_commit(std::chrono::milliseconds(1000));
if (result != "OK") {
return -1;
}
} catch(std::exception &e) {
return -1;
}
return 0;
}
int RGWD4NCache::delObject(std::string oid) {
int result = 0;
std::vector<std::string> keys;
std::string key = "rgw-object:" + oid + ":cache";
keys.push_back(key);
if (!client.is_connected()) {
findClient(&client);
}
if (existKey(key)) {
try {
client.del(keys, [&result](cpp_redis::reply &reply) {
if (reply.is_integer()) {
result = reply.as_integer();
}
});
client.sync_commit(std::chrono::milliseconds(1000));
return result - 1;
} catch(std::exception &e) {
return -1;
}
} else {
dout(20) << "RGW D4N Cache: Object is not in cache." << dendl;
return -2;
}
}
int RGWD4NCache::updateAttr(std::string oid, rgw::sal::Attrs* attr) {
std::string result;
std::string key = "rgw-object:" + oid + ":cache";
if (!client.is_connected()) {
findClient(&client);
}
if (existKey(key)) {
try {
std::vector< std::pair<std::string, std::string> > redisObject;
auto it = attr->begin();
redisObject.push_back({it->first, it->second.to_str()});
client.hmset(key, redisObject, [&result](cpp_redis::reply &reply) {
if (!reply.is_null()) {
result = reply.as_string();
}
});
client.sync_commit(std::chrono::milliseconds(1000));
if (result != "OK") {
return -1;
}
} catch(std::exception &e) {
return -1;
}
} else {
return -2;
}
return 0;
}
int RGWD4NCache::delAttrs(std::string oid, std::vector<std::string>& baseFields, std::vector<std::string>& deleteFields) {
int result = 0;
std::string key = "rgw-object:" + oid + ":cache";
if (!client.is_connected()) {
findClient(&client);
}
if (existKey(key)) {
/* Find if attribute doesn't exist */
for (const auto& delField : deleteFields) {
if (std::find(baseFields.begin(), baseFields.end(), delField) == baseFields.end()) {
deleteFields.erase(std::find(deleteFields.begin(), deleteFields.end(), delField));
}
}
try {
client.hdel(key, deleteFields, [&result](cpp_redis::reply &reply) {
if (reply.is_integer()) {
result = reply.as_integer();
}
});
client.sync_commit(std::chrono::milliseconds(1000));
return result - 1;
} catch(std::exception &e) {
return -1;
}
}
dout(20) << "RGW D4N Cache: Object is not in cache." << dendl;
return -2;
}
int RGWD4NCache::appendData(std::string oid, buffer::list& data) {
std::string result;
std::string value = "";
std::string key = "rgw-object:" + oid + ":cache";
if (!client.is_connected()) {
findClient(&client);
}
if (existKey(key)) {
try {
client.hget(key, "data", [&value](cpp_redis::reply &reply) {
if (!reply.is_null()) {
value = reply.as_string();
}
});
client.sync_commit(std::chrono::milliseconds(1000));
} catch(std::exception &e) {
return -1;
}
}
try {
/* Append to existing value or set as new value */
std::string temp = value + data.to_str();
std::vector< std::pair<std::string, std::string> > field;
field.push_back({"data", temp});
client.hmset(key, field, [&result](cpp_redis::reply &reply) {
if (!reply.is_null()) {
result = reply.as_string();
}
});
client.sync_commit(std::chrono::milliseconds(1000));
if (result != "OK") {
return -1;
}
} catch(std::exception &e) {
return -1;
}
return 0;
}
int RGWD4NCache::deleteData(std::string oid) {
int result = 0;
std::string key = "rgw-object:" + oid + ":cache";
std::vector<std::string> deleteField;
deleteField.push_back("data");
if (!client.is_connected()) {
findClient(&client);
}
if (existKey(key)) {
int field_exist = -1;
try {
client.hget(key, "data", [&field_exist](cpp_redis::reply &reply) {
if (!reply.is_null()) {
field_exist = 0;
}
});
client.sync_commit(std::chrono::milliseconds(1000));
} catch(std::exception &e) {
return -1;
}
if (field_exist == 0) {
try {
client.hdel(key, deleteField, [&result](cpp_redis::reply &reply) {
if (reply.is_integer()) {
result = reply.as_integer(); /* Returns 1 upon success */
}
});
client.sync_commit(std::chrono::milliseconds(1000));
return result - 1;
} catch(std::exception &e) {
return -1;
}
} else {
return -1;
}
} else {
return 0; /* No delete was necessary */
}
}
| 11,770 | 22.973523 | 122 |
cc
|
null |
ceph-main/src/rgw/driver/d4n/d4n_datacache.h
|
#ifndef CEPH_RGWD4NCACHE_H
#define CEPH_RGWD4NCACHE_H
#include "rgw_common.h"
#include <cpp_redis/cpp_redis>
#include <string>
#include <iostream>
class RGWD4NCache {
public:
CephContext *cct;
RGWD4NCache() {}
RGWD4NCache(std::string cacheHost, int cachePort):host(cacheHost), port(cachePort) {}
void init(CephContext *_cct) {
cct = _cct;
host = cct->_conf->rgw_d4n_host;
port = cct->_conf->rgw_d4n_port;
}
int findClient(cpp_redis::client *client);
int existKey(std::string key);
int setObject(std::string oid, rgw::sal::Attrs* attrs);
int getObject(std::string oid, rgw::sal::Attrs* newAttrs, std::vector< std::pair<std::string, std::string> >* newMetadata);
int copyObject(std::string original_oid, std::string copy_oid, rgw::sal::Attrs* attrs);
int delObject(std::string oid);
int updateAttr(std::string oid, rgw::sal::Attrs* attr);
int delAttrs(std::string oid, std::vector<std::string>& baseFields, std::vector<std::string>& deleteFields);
int appendData(std::string oid, buffer::list& data);
int deleteData(std::string oid);
private:
cpp_redis::client client;
std::string host = "";
int port = 0;
std::vector< std::pair<std::string, std::string> > buildObject(rgw::sal::Attrs* binary);
};
#endif
| 1,308 | 30.926829 | 127 |
h
|
null |
ceph-main/src/rgw/driver/d4n/d4n_directory.cc
|
#include "d4n_directory.h"
#define dout_subsys ceph_subsys_rgw
#define dout_context g_ceph_context
int RGWBlockDirectory::findClient(cpp_redis::client *client) {
if (client->is_connected())
return 0;
if (host == "" || port == 0) {
dout(10) << "RGW D4N Directory: D4N directory endpoint was not configured correctly" << dendl;
return EDESTADDRREQ;
}
client->connect(host, port, nullptr);
if (!client->is_connected())
return ECONNREFUSED;
return 0;
}
std::string RGWBlockDirectory::buildIndex(cache_block *ptr) {
return "rgw-object:" + ptr->c_obj.obj_name + ":directory";
}
int RGWBlockDirectory::existKey(std::string key) {
int result = -1;
std::vector<std::string> keys;
keys.push_back(key);
if (!client.is_connected()) {
return result;
}
try {
client.exists(keys, [&result](cpp_redis::reply &reply) {
if (reply.is_integer()) {
result = reply.as_integer(); /* Returns 1 upon success */
}
});
client.sync_commit(std::chrono::milliseconds(1000));
} catch(std::exception &e) {}
return result;
}
int RGWBlockDirectory::setValue(cache_block *ptr) {
/* Creating the index based on obj_name */
std::string key = buildIndex(ptr);
if (!client.is_connected()) {
findClient(&client);
}
std::string result;
std::vector<std::string> keys;
keys.push_back(key);
/* Every set will be new */
if (host == "" || port == 0) {
dout(10) << "RGW D4N Directory: Directory endpoint not configured correctly" << dendl;
return -1;
}
std::string endpoint = host + ":" + std::to_string(port);
std::vector<std::pair<std::string, std::string>> list;
/* Creating a list of key's properties */
list.push_back(make_pair("key", key));
list.push_back(make_pair("size", std::to_string(ptr->size_in_bytes)));
list.push_back(make_pair("bucket_name", ptr->c_obj.bucket_name));
list.push_back(make_pair("obj_name", ptr->c_obj.obj_name));
list.push_back(make_pair("hosts", endpoint));
try {
client.hmset(key, list, [&result](cpp_redis::reply &reply) {
if (!reply.is_null()) {
result = reply.as_string();
}
});
client.sync_commit(std::chrono::milliseconds(1000));
if (result != "OK") {
return -1;
}
} catch(std::exception &e) {
return -1;
}
return 0;
}
int RGWBlockDirectory::getValue(cache_block *ptr) {
std::string key = buildIndex(ptr);
if (!client.is_connected()) {
findClient(&client);
}
if (existKey(key)) {
int field_exist = -1;
std::string hosts;
std::string size;
std::string bucket_name;
std::string obj_name;
std::vector<std::string> fields;
fields.push_back("key");
fields.push_back("hosts");
fields.push_back("size");
fields.push_back("bucket_name");
fields.push_back("obj_name");
try {
client.hmget(key, fields, [&key, &hosts, &size, &bucket_name, &obj_name, &field_exist](cpp_redis::reply &reply) {
if (reply.is_array()) {
auto arr = reply.as_array();
if (!arr[0].is_null()) {
field_exist = 0;
key = arr[0].as_string();
hosts = arr[1].as_string();
size = arr[2].as_string();
bucket_name = arr[3].as_string();
obj_name = arr[4].as_string();
}
}
});
client.sync_commit(std::chrono::milliseconds(1000));
if (field_exist < 0) {
return field_exist;
}
/* Currently, there can only be one host */
ptr->size_in_bytes = std::stoi(size);
ptr->c_obj.bucket_name = bucket_name;
ptr->c_obj.obj_name = obj_name;
} catch(std::exception &e) {
return -1;
}
}
return 0;
}
int RGWBlockDirectory::delValue(cache_block *ptr) {
int result = 0;
std::vector<std::string> keys;
std::string key = buildIndex(ptr);
keys.push_back(key);
if (!client.is_connected()) {
findClient(&client);
}
if (existKey(key)) {
try {
client.del(keys, [&result](cpp_redis::reply &reply) {
if (reply.is_integer()) {
result = reply.as_integer(); /* Returns 1 upon success */
}
});
client.sync_commit(std::chrono::milliseconds(1000));
return result - 1;
} catch(std::exception &e) {
return -1;
}
} else {
dout(20) << "RGW D4N Directory: Block is not in directory." << dendl;
return -2;
}
}
| 4,354 | 23.194444 | 119 |
cc
|
null |
ceph-main/src/rgw/driver/d4n/d4n_directory.h
|
#ifndef CEPH_RGWD4NDIRECTORY_H
#define CEPH_RGWD4NDIRECTORY_H
#include "rgw_common.h"
#include <cpp_redis/cpp_redis>
#include <string>
#include <iostream>
struct cache_obj {
std::string bucket_name; /* s3 bucket name */
std::string obj_name; /* s3 obj name */
};
struct cache_block {
cache_obj c_obj;
uint64_t size_in_bytes; /* block size_in_bytes */
std::vector<std::string> hosts_list; /* Currently not supported: list of hostnames <ip:port> of block locations */
};
class RGWDirectory {
public:
RGWDirectory() {}
CephContext *cct;
};
class RGWBlockDirectory: RGWDirectory {
public:
RGWBlockDirectory() {}
RGWBlockDirectory(std::string blockHost, int blockPort):host(blockHost), port(blockPort) {}
void init(CephContext *_cct) {
cct = _cct;
host = cct->_conf->rgw_d4n_host;
port = cct->_conf->rgw_d4n_port;
}
int findClient(cpp_redis::client *client);
int existKey(std::string key);
int setValue(cache_block *ptr);
int getValue(cache_block *ptr);
int delValue(cache_block *ptr);
std::string get_host() { return host; }
int get_port() { return port; }
private:
cpp_redis::client client;
std::string buildIndex(cache_block *ptr);
std::string host = "";
int port = 0;
};
#endif
| 1,294 | 22.981481 | 116 |
h
|
null |
ceph-main/src/rgw/driver/d4n/rgw_sal_d4n.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2022 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "rgw_sal_d4n.h"
#define dout_subsys ceph_subsys_rgw
#define dout_context g_ceph_context
namespace rgw { namespace sal {
static inline Bucket* nextBucket(Bucket* t)
{
if (!t)
return nullptr;
return dynamic_cast<FilterBucket*>(t)->get_next();
}
static inline Object* nextObject(Object* t)
{
if (!t)
return nullptr;
return dynamic_cast<FilterObject*>(t)->get_next();
}
int D4NFilterDriver::initialize(CephContext *cct, const DoutPrefixProvider *dpp)
{
FilterDriver::initialize(cct, dpp);
blk_dir->init(cct);
d4n_cache->init(cct);
return 0;
}
std::unique_ptr<User> D4NFilterDriver::get_user(const rgw_user &u)
{
std::unique_ptr<User> user = next->get_user(u);
return std::make_unique<D4NFilterUser>(std::move(user), this);
}
std::unique_ptr<Object> D4NFilterBucket::get_object(const rgw_obj_key& k)
{
std::unique_ptr<Object> o = next->get_object(k);
return std::make_unique<D4NFilterObject>(std::move(o), this, filter);
}
int D4NFilterUser::create_bucket(const DoutPrefixProvider* dpp,
const rgw_bucket& b,
const std::string& zonegroup_id,
rgw_placement_rule& placement_rule,
std::string& swift_ver_location,
const RGWQuotaInfo * pquota_info,
const RGWAccessControlPolicy& policy,
Attrs& attrs,
RGWBucketInfo& info,
obj_version& ep_objv,
bool exclusive,
bool obj_lock_enabled,
bool* existed,
req_info& req_info,
std::unique_ptr<Bucket>* bucket_out,
optional_yield y)
{
std::unique_ptr<Bucket> nb;
int ret;
ret = next->create_bucket(dpp, b, zonegroup_id, placement_rule, swift_ver_location, pquota_info, policy, attrs, info, ep_objv, exclusive, obj_lock_enabled, existed, req_info, &nb, y);
if (ret < 0)
return ret;
Bucket* fb = new D4NFilterBucket(std::move(nb), this, filter);
bucket_out->reset(fb);
return 0;
}
int D4NFilterObject::copy_object(User* user,
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,
const ceph::real_time* mod_ptr,
const ceph::real_time* unmod_ptr,
bool high_precision_time,
const char* if_match,
const char* if_nomatch,
AttrsMod attrs_mod,
bool copy_if_newer,
Attrs& attrs,
RGWObjCategory category,
uint64_t olh_epoch,
boost::optional<ceph::real_time> delete_at,
std::string* version_id,
std::string* tag,
std::string* etag,
void (*progress_cb)(off_t, void *),
void* progress_data,
const DoutPrefixProvider* dpp,
optional_yield y)
{
/* Append additional metadata to attributes */
rgw::sal::Attrs baseAttrs = this->get_attrs();
buffer::list bl;
bl.append(to_iso_8601(*mtime));
baseAttrs.insert({"mtime", bl});
bl.clear();
if (version_id != NULL) {
bl.append(*version_id);
baseAttrs.insert({"version_id", bl});
bl.clear();
}
if (!etag->empty()) {
bl.append(*etag);
baseAttrs.insert({"etag", bl});
bl.clear();
}
if (attrs_mod == rgw::sal::ATTRSMOD_REPLACE) { /* Replace */
rgw::sal::Attrs::iterator iter;
for (const auto& pair : attrs) {
iter = baseAttrs.find(pair.first);
if (iter != baseAttrs.end()) {
iter->second = pair.second;
} else {
baseAttrs.insert({pair.first, pair.second});
}
}
} else if (attrs_mod == rgw::sal::ATTRSMOD_MERGE) { /* Merge */
baseAttrs.insert(attrs.begin(), attrs.end());
}
int copyObjReturn = filter->get_d4n_cache()->copyObject(this->get_key().get_oid(), dest_object->get_key().get_oid(), &baseAttrs);
if (copyObjReturn < 0) {
ldpp_dout(dpp, 20) << "D4N Filter: Cache copy object operation failed." << dendl;
} else {
ldpp_dout(dpp, 20) << "D4N Filter: Cache copy object operation succeeded." << dendl;
}
return next->copy_object(user, info, source_zone,
nextObject(dest_object),
nextBucket(dest_bucket),
nextBucket(src_bucket),
dest_placement, src_mtime, mtime,
mod_ptr, unmod_ptr, high_precision_time, if_match,
if_nomatch, attrs_mod, copy_if_newer, attrs,
category, olh_epoch, delete_at, version_id, tag,
etag, progress_cb, progress_data, dpp, y);
}
int D4NFilterObject::set_obj_attrs(const DoutPrefixProvider* dpp, Attrs* setattrs,
Attrs* delattrs, optional_yield y)
{
if (setattrs != NULL) {
/* Ensure setattrs and delattrs do not overlap */
if (delattrs != NULL) {
for (const auto& attr : *delattrs) {
if (std::find(setattrs->begin(), setattrs->end(), attr) != setattrs->end()) {
delattrs->erase(std::find(delattrs->begin(), delattrs->end(), attr));
}
}
}
int updateAttrsReturn = filter->get_d4n_cache()->setObject(this->get_key().get_oid(), setattrs);
if (updateAttrsReturn < 0) {
ldpp_dout(dpp, 20) << "D4N Filter: Cache set object attributes operation failed." << dendl;
} else {
ldpp_dout(dpp, 20) << "D4N Filter: Cache set object attributes operation succeeded." << dendl;
}
}
if (delattrs != NULL) {
std::vector<std::string> delFields;
Attrs::iterator attrs;
/* Extract fields from delattrs */
for (attrs = delattrs->begin(); attrs != delattrs->end(); ++attrs) {
delFields.push_back(attrs->first);
}
Attrs currentattrs = this->get_attrs();
std::vector<std::string> currentFields;
/* Extract fields from current attrs */
for (attrs = currentattrs.begin(); attrs != currentattrs.end(); ++attrs) {
currentFields.push_back(attrs->first);
}
int delAttrsReturn = filter->get_d4n_cache()->delAttrs(this->get_key().get_oid(), currentFields, delFields);
if (delAttrsReturn < 0) {
ldpp_dout(dpp, 20) << "D4N Filter: Cache delete object attributes operation failed." << dendl;
} else {
ldpp_dout(dpp, 20) << "D4N Filter: Cache delete object attributes operation succeeded." << dendl;
}
}
return next->set_obj_attrs(dpp, setattrs, delattrs, y);
}
int D4NFilterObject::get_obj_attrs(optional_yield y, const DoutPrefixProvider* dpp,
rgw_obj* target_obj)
{
rgw::sal::Attrs newAttrs;
std::vector< std::pair<std::string, std::string> > newMetadata;
int getAttrsReturn = filter->get_d4n_cache()->getObject(this->get_key().get_oid(),
&newAttrs,
&newMetadata);
if (getAttrsReturn < 0) {
ldpp_dout(dpp, 20) << "D4N Filter: Cache get object attributes operation failed." << dendl;
return next->get_obj_attrs(y, dpp, target_obj);
} else {
int setAttrsReturn = this->set_attrs(newAttrs);
if (setAttrsReturn < 0) {
ldpp_dout(dpp, 20) << "D4N Filter: Cache get object attributes operation failed." << dendl;
return next->get_obj_attrs(y, dpp, target_obj);
} else {
ldpp_dout(dpp, 20) << "D4N Filter: Cache get object attributes operation succeeded." << dendl;
return 0;
}
}
}
int D4NFilterObject::modify_obj_attrs(const char* attr_name, bufferlist& attr_val,
optional_yield y, const DoutPrefixProvider* dpp)
{
Attrs update;
update[(std::string)attr_name] = attr_val;
int updateAttrsReturn = filter->get_d4n_cache()->updateAttr(this->get_key().get_oid(), &update);
if (updateAttrsReturn < 0) {
ldpp_dout(dpp, 20) << "D4N Filter: Cache modify object attribute operation failed." << dendl;
} else {
ldpp_dout(dpp, 20) << "D4N Filter: Cache modify object attribute operation succeeded." << dendl;
}
return next->modify_obj_attrs(attr_name, attr_val, y, dpp);
}
int D4NFilterObject::delete_obj_attrs(const DoutPrefixProvider* dpp, const char* attr_name,
optional_yield y)
{
std::vector<std::string> delFields;
delFields.push_back((std::string)attr_name);
Attrs::iterator attrs;
Attrs currentattrs = this->get_attrs();
std::vector<std::string> currentFields;
/* Extract fields from current attrs */
for (attrs = currentattrs.begin(); attrs != currentattrs.end(); ++attrs) {
currentFields.push_back(attrs->first);
}
int delAttrReturn = filter->get_d4n_cache()->delAttrs(this->get_key().get_oid(), currentFields, delFields);
if (delAttrReturn < 0) {
ldpp_dout(dpp, 20) << "D4N Filter: Cache delete object attribute operation failed." << dendl;
} else {
ldpp_dout(dpp, 20) << "D4N Filter: Cache delete object attribute operation succeeded." << dendl;
}
return next->delete_obj_attrs(dpp, attr_name, y);
}
std::unique_ptr<Object> D4NFilterDriver::get_object(const rgw_obj_key& k)
{
std::unique_ptr<Object> o = next->get_object(k);
return std::make_unique<D4NFilterObject>(std::move(o), this);
}
std::unique_ptr<Writer> D4NFilterDriver::get_atomic_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag)
{
std::unique_ptr<Writer> writer = next->get_atomic_writer(dpp, y, nextObject(obj),
owner, ptail_placement_rule,
olh_epoch, unique_tag);
return std::make_unique<D4NFilterWriter>(std::move(writer), this, obj, dpp, true);
}
std::unique_ptr<Object::ReadOp> D4NFilterObject::get_read_op()
{
std::unique_ptr<ReadOp> r = next->get_read_op();
return std::make_unique<D4NFilterReadOp>(std::move(r), this);
}
std::unique_ptr<Object::DeleteOp> D4NFilterObject::get_delete_op()
{
std::unique_ptr<DeleteOp> d = next->get_delete_op();
return std::make_unique<D4NFilterDeleteOp>(std::move(d), this);
}
int D4NFilterObject::D4NFilterReadOp::prepare(optional_yield y, const DoutPrefixProvider* dpp)
{
int getDirReturn = source->filter->get_block_dir()->getValue(source->filter->get_cache_block());
if (getDirReturn < 0) {
ldpp_dout(dpp, 20) << "D4N Filter: Directory get operation failed." << dendl;
} else {
ldpp_dout(dpp, 20) << "D4N Filter: Directory get operation succeeded." << dendl;
}
rgw::sal::Attrs newAttrs;
std::vector< std::pair<std::string, std::string> > newMetadata;
int getObjReturn = source->filter->get_d4n_cache()->getObject(source->get_key().get_oid(),
&newAttrs,
&newMetadata);
int ret = next->prepare(y, dpp);
if (getObjReturn < 0) {
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);
for (auto it = newMetadata.begin(); it != newMetadata.end(); ++it) {
if (!std::strcmp(it->first.data(), "mtime")) {
parse_time(it->second.data(), &astate->mtime);
} else if (!std::strcmp(it->first.data(), "object_size")) {
source->set_obj_size(std::stoull(it->second));
} else if (!std::strcmp(it->first.data(), "accounted_size")) {
astate->accounted_size = std::stoull(it->second);
} else if (!std::strcmp(it->first.data(), "epoch")) {
astate->epoch = std::stoull(it->second);
} else if (!std::strcmp(it->first.data(), "version_id")) {
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(), "bucket_count")) {
source->get_bucket()->set_count(std::stoull(it->second));
} else if (!std::strcmp(it->first.data(), "bucket_size")) {
source->get_bucket()->set_size(std::stoull(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 */
int setAttrsReturn = source->set_attrs(newAttrs);
if (setAttrsReturn < 0) {
ldpp_dout(dpp, 20) << "D4N Filter: Cache get object operation failed." << dendl;
} else {
ldpp_dout(dpp, 20) << "D4N Filter: Cache get object operation succeeded." << dendl;
}
}
return ret;
}
int D4NFilterObject::D4NFilterDeleteOp::delete_obj(const DoutPrefixProvider* dpp,
optional_yield y)
{
int delDirReturn = source->filter->get_block_dir()->delValue(source->filter->get_cache_block());
if (delDirReturn < 0) {
ldpp_dout(dpp, 20) << "D4N Filter: Directory delete operation failed." << dendl;
} else {
ldpp_dout(dpp, 20) << "D4N Filter: Directory delete operation succeeded." << dendl;
}
int delObjReturn = source->filter->get_d4n_cache()->delObject(source->get_key().get_oid());
if (delObjReturn < 0) {
ldpp_dout(dpp, 20) << "D4N Filter: Cache delete operation failed." << dendl;
} else {
ldpp_dout(dpp, 20) << "D4N Filter: Cache delete operation succeeded." << dendl;
}
return next->delete_obj(dpp, y);
}
int D4NFilterWriter::prepare(optional_yield y)
{
int delDataReturn = filter->get_d4n_cache()->deleteData(obj->get_key().get_oid());
if (delDataReturn < 0) {
ldpp_dout(save_dpp, 20) << "D4N Filter: Cache delete data operation failed." << dendl;
} else {
ldpp_dout(save_dpp, 20) << "D4N Filter: Cache delete data operation succeeded." << dendl;
}
return next->prepare(y);
}
int D4NFilterWriter::process(bufferlist&& data, uint64_t offset)
{
int appendDataReturn = filter->get_d4n_cache()->appendData(obj->get_key().get_oid(), data);
if (appendDataReturn < 0) {
ldpp_dout(save_dpp, 20) << "D4N Filter: Cache append data operation failed." << dendl;
} else {
ldpp_dout(save_dpp, 20) << "D4N Filter: Cache append data operation succeeded." << dendl;
}
return next->process(std::move(data), offset);
}
int D4NFilterWriter::complete(size_t accounted_size, const std::string& etag,
ceph::real_time *mtime, ceph::real_time set_mtime,
std::map<std::string, bufferlist>& attrs,
ceph::real_time delete_at,
const char *if_match, const char *if_nomatch,
const std::string *user_data,
rgw_zone_set *zones_trace, bool *canceled,
optional_yield y)
{
cache_block* temp_cache_block = filter->get_cache_block();
RGWBlockDirectory* temp_block_dir = filter->get_block_dir();
temp_cache_block->hosts_list.push_back(temp_block_dir->get_host() + ":" + std::to_string(temp_block_dir->get_port()));
temp_cache_block->size_in_bytes = accounted_size;
temp_cache_block->c_obj.bucket_name = obj->get_bucket()->get_name();
temp_cache_block->c_obj.obj_name = obj->get_key().get_oid();
int setDirReturn = temp_block_dir->setValue(temp_cache_block);
if (setDirReturn < 0) {
ldpp_dout(save_dpp, 20) << "D4N Filter: Directory set operation failed." << dendl;
} else {
ldpp_dout(save_dpp, 20) << "D4N Filter: Directory set operation succeeded." << dendl;
}
/* Retrieve complete set of attrs */
RGWObjState* astate;
int ret = next->complete(accounted_size, etag, mtime, set_mtime, attrs,
delete_at, if_match, if_nomatch, user_data, zones_trace,
canceled, y);
obj->get_obj_attrs(y, save_dpp, NULL);
obj->get_obj_state(save_dpp, &astate, y);
/* Append additional metadata to attributes */
rgw::sal::Attrs baseAttrs = obj->get_attrs();
rgw::sal::Attrs attrs_temp = baseAttrs;
buffer::list bl;
bl.append(to_iso_8601(obj->get_mtime()));
baseAttrs.insert({"mtime", bl});
bl.clear();
bl.append(std::to_string(obj->get_obj_size()));
baseAttrs.insert({"object_size", bl});
bl.clear();
bl.append(std::to_string(accounted_size));
baseAttrs.insert({"accounted_size", bl});
bl.clear();
bl.append(std::to_string(astate->epoch));
baseAttrs.insert({"epoch", bl});
bl.clear();
if (obj->have_instance()) {
bl.append(obj->get_instance());
baseAttrs.insert({"version_id", bl});
bl.clear();
} else {
bl.append(""); /* Empty value */
baseAttrs.insert({"version_id", bl});
bl.clear();
}
auto iter = attrs_temp.find(RGW_ATTR_SOURCE_ZONE);
if (iter != attrs_temp.end()) {
bl.append(std::to_string(astate->zone_short_id));
baseAttrs.insert({"source_zone_short_id", bl});
bl.clear();
} else {
bl.append("0"); /* Initialized to zero */
baseAttrs.insert({"source_zone_short_id", bl});
bl.clear();
}
bl.append(std::to_string(obj->get_bucket()->get_count()));
baseAttrs.insert({"bucket_count", bl});
bl.clear();
bl.append(std::to_string(obj->get_bucket()->get_size()));
baseAttrs.insert({"bucket_size", bl});
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);
if (setObjReturn < 0) {
ldpp_dout(save_dpp, 20) << "D4N Filter: Cache set operation failed." << dendl;
} else {
ldpp_dout(save_dpp, 20) << "D4N Filter: Cache set operation succeeded." << dendl;
}
return ret;
}
} } // namespace rgw::sal
extern "C" {
rgw::sal::Driver* newD4NFilter(rgw::sal::Driver* next)
{
rgw::sal::D4NFilterDriver* driver = new rgw::sal::D4NFilterDriver(next);
return driver;
}
}
| 19,718 | 33.777778 | 185 |
cc
|
null |
ceph-main/src/rgw/driver/d4n/rgw_sal_d4n.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2022 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#pragma once
#include "rgw_sal_filter.h"
#include "rgw_sal.h"
#include "rgw_oidc_provider.h"
#include "rgw_role.h"
#include "common/dout.h"
#include "driver/d4n/d4n_directory.h"
#include "driver/d4n/d4n_datacache.h"
namespace rgw { namespace sal {
class D4NFilterDriver : public FilterDriver {
private:
RGWBlockDirectory* blk_dir;
cache_block* c_blk;
RGWD4NCache* d4n_cache;
public:
D4NFilterDriver(Driver* _next) : FilterDriver(_next)
{
blk_dir = new RGWBlockDirectory(); /* Initialize directory address with cct */
c_blk = new cache_block();
d4n_cache = new RGWD4NCache();
}
virtual ~D4NFilterDriver() {
delete blk_dir;
delete c_blk;
delete d4n_cache;
}
virtual int initialize(CephContext *cct, const DoutPrefixProvider *dpp) override;
virtual std::unique_ptr<User> get_user(const rgw_user& u) override;
virtual std::unique_ptr<Object> get_object(const rgw_obj_key& k) override;
virtual std::unique_ptr<Writer> get_atomic_writer(const DoutPrefixProvider *dpp,
optional_yield y,
rgw::sal::Object* obj,
const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag) override;
RGWBlockDirectory* get_block_dir() { return blk_dir; }
cache_block* get_cache_block() { return c_blk; }
RGWD4NCache* get_d4n_cache() { return d4n_cache; }
};
class D4NFilterUser : public FilterUser {
private:
D4NFilterDriver* filter;
public:
D4NFilterUser(std::unique_ptr<User> _next, D4NFilterDriver* _filter) :
FilterUser(std::move(_next)),
filter(_filter) {}
virtual ~D4NFilterUser() = default;
virtual int create_bucket(const DoutPrefixProvider* dpp,
const rgw_bucket& b,
const std::string& zonegroup_id,
rgw_placement_rule& placement_rule,
std::string& swift_ver_location,
const RGWQuotaInfo* pquota_info,
const RGWAccessControlPolicy& policy,
Attrs& attrs,
RGWBucketInfo& info,
obj_version& ep_objv,
bool exclusive,
bool obj_lock_enabled,
bool* existed,
req_info& req_info,
std::unique_ptr<Bucket>* bucket,
optional_yield y) override;
};
class D4NFilterBucket : public FilterBucket {
private:
D4NFilterDriver* filter;
public:
D4NFilterBucket(std::unique_ptr<Bucket> _next, User* _user, D4NFilterDriver* _filter) :
FilterBucket(std::move(_next), _user),
filter(_filter) {}
virtual ~D4NFilterBucket() = default;
virtual std::unique_ptr<Object> get_object(const rgw_obj_key& key) override;
};
class D4NFilterObject : public FilterObject {
private:
D4NFilterDriver* filter;
public:
struct D4NFilterReadOp : FilterReadOp {
D4NFilterObject* source;
D4NFilterReadOp(std::unique_ptr<ReadOp> _next, D4NFilterObject* _source) : FilterReadOp(std::move(_next)),
source(_source) {}
virtual ~D4NFilterReadOp() = default;
virtual int prepare(optional_yield y, const DoutPrefixProvider* dpp) override;
};
struct D4NFilterDeleteOp : FilterDeleteOp {
D4NFilterObject* source;
D4NFilterDeleteOp(std::unique_ptr<DeleteOp> _next, D4NFilterObject* _source) : FilterDeleteOp(std::move(_next)),
source(_source) {}
virtual ~D4NFilterDeleteOp() = default;
virtual int delete_obj(const DoutPrefixProvider* dpp, optional_yield y) override;
};
D4NFilterObject(std::unique_ptr<Object> _next, D4NFilterDriver* _filter) : FilterObject(std::move(_next)),
filter(_filter) {}
D4NFilterObject(std::unique_ptr<Object> _next, Bucket* _bucket, D4NFilterDriver* _filter) : FilterObject(std::move(_next), _bucket),
filter(_filter) {}
D4NFilterObject(D4NFilterObject& _o, D4NFilterDriver* _filter) : FilterObject(_o),
filter(_filter) {}
virtual ~D4NFilterObject() = default;
virtual int copy_object(User* user,
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,
const ceph::real_time* mod_ptr, const ceph::real_time* unmod_ptr,
bool high_precision_time,
const char* if_match, const char* if_nomatch,
AttrsMod attrs_mod, bool copy_if_newer, Attrs& attrs,
RGWObjCategory category, uint64_t olh_epoch,
boost::optional<ceph::real_time> delete_at,
std::string* version_id, std::string* tag, std::string* etag,
void (*progress_cb)(off_t, void *), void* progress_data,
const DoutPrefixProvider* dpp, optional_yield y) override;
virtual const std::string &get_name() const override { return next->get_name(); }
virtual int set_obj_attrs(const DoutPrefixProvider* dpp, Attrs* setattrs,
Attrs* delattrs, optional_yield y) override;
virtual int get_obj_attrs(optional_yield y, const DoutPrefixProvider* dpp,
rgw_obj* target_obj = NULL) override;
virtual int modify_obj_attrs(const char* attr_name, bufferlist& attr_val,
optional_yield y, const DoutPrefixProvider* dpp) override;
virtual int delete_obj_attrs(const DoutPrefixProvider* dpp, const char* attr_name,
optional_yield y) override;
virtual std::unique_ptr<ReadOp> get_read_op() override;
virtual std::unique_ptr<DeleteOp> get_delete_op() override;
};
class D4NFilterWriter : public FilterWriter {
private:
D4NFilterDriver* filter;
const DoutPrefixProvider* save_dpp;
bool atomic;
public:
D4NFilterWriter(std::unique_ptr<Writer> _next, D4NFilterDriver* _filter, Object* _obj,
const DoutPrefixProvider* _dpp) : FilterWriter(std::move(_next), _obj),
filter(_filter),
save_dpp(_dpp), atomic(false) {}
D4NFilterWriter(std::unique_ptr<Writer> _next, D4NFilterDriver* _filter, Object* _obj,
const DoutPrefixProvider* _dpp, bool _atomic) : FilterWriter(std::move(_next), _obj),
filter(_filter),
save_dpp(_dpp), atomic(_atomic) {}
virtual ~D4NFilterWriter() = default;
virtual int prepare(optional_yield y);
virtual int process(bufferlist&& data, uint64_t offset) override;
virtual int complete(size_t accounted_size, const std::string& etag,
ceph::real_time *mtime, ceph::real_time set_mtime,
std::map<std::string, bufferlist>& attrs,
ceph::real_time delete_at,
const char *if_match, const char *if_nomatch,
const std::string *user_data,
rgw_zone_set *zones_trace, bool *canceled,
optional_yield y) override;
bool is_atomic() { return atomic; };
const DoutPrefixProvider* dpp() { return save_dpp; }
};
} } // namespace rgw::sal
| 7,876 | 38.385 | 136 |
h
|
null |
ceph-main/src/rgw/driver/dbstore/dbstore_main.cc
|
#include <stdio.h>
#include <sqlite3.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include "dbstore_mgr.h"
#include <dbstore.h>
#include <dbstore_log.h>
using namespace std;
using namespace rgw::store;
using DB = rgw::store::DB;
struct thr_args {
DB *dbs;
int thr_id;
};
void* process(void *arg)
{
struct thr_args *t_args = (struct thr_args*)arg;
DB *db = t_args->dbs;
int thr_id = t_args->thr_id;
int ret = -1;
cout<<"Entered thread:"<<thr_id<<"\n";
string user1 = "User1";
string bucketa = "rgw";
string objecta1 = "bugfixing";
string objecta2 = "zipper";
string bucketb = "gluster";
string objectb1 = "bugfixing";
string objectb2 = "delegations";
string user2 = "User2";
string bucketc = "qe";
string objectc1 = "rhhi";
string objectc2 = "cns";
DBOpParams params = {};
const DoutPrefixProvider *dpp = db->get_def_dpp();
db->InitializeParams(dpp, ¶ms);
params.op.user.uinfo.display_name = user1;
params.op.user.uinfo.user_id.tenant = "tenant";
params.op.user.uinfo.user_id.id = user1;
params.op.user.uinfo.suspended = 123;
params.op.user.uinfo.max_buckets = 456;
params.op.user.uinfo.placement_tags.push_back("tags1");
params.op.user.uinfo.placement_tags.push_back("tags2");
RGWAccessKey k1("id1", "key1");
RGWAccessKey k2("id2", "key2");
params.op.user.uinfo.access_keys.insert(make_pair("key1", k1));
params.op.user.uinfo.access_keys.insert(make_pair("key2", k2));
ret = db->ProcessOp(dpp, "InsertUser", ¶ms);
cout << "InsertUser return value: " << ret << "\n";
DBOpParams params2 = {};
params.op.user.uinfo.user_id.tenant = "tenant2";
db->InitializeParams(dpp, ¶ms2);
params2.op.user.uinfo.display_name = user1;
ret = db->ProcessOp(dpp, "GetUser", ¶ms2);
cout << "GetUser return value: " << ret << "\n";
cout << "tenant: " << params2.op.user.uinfo.user_id.tenant << "\n";
cout << "suspended: " << (int)params2.op.user.uinfo.suspended << "\n";
list<string>::iterator it = params2.op.user.uinfo.placement_tags.begin();
while (it != params2.op.user.uinfo.placement_tags.end()) {
cout << "list = " << *it << "\n";
it++;
}
map<string, RGWAccessKey>::iterator it2 = params2.op.user.uinfo.access_keys.begin();
while (it2 != params2.op.user.uinfo.access_keys.end()) {
cout << "keys = " << it2->first << "\n";
RGWAccessKey k = it2->second;
cout << "id = " << k.id << ", keys = " << k.key << "\n";
it2++;
}
params.op.bucket.info.bucket.name = bucketa;
db->ProcessOp(dpp, "InsertBucket", ¶ms);
params.op.user.uinfo.display_name = user2;
params.op.user.uinfo.user_id.id = user2;
db->ProcessOp(dpp, "InsertUser", ¶ms);
params.op.bucket.info.bucket.name = bucketb;
db->ProcessOp(dpp, "InsertBucket", ¶ms);
db->ProcessOp(dpp, "GetUser", ¶ms);
db->ProcessOp(dpp, "GetBucket", ¶ms);
db->ListAllUsers(dpp, ¶ms);
db->ListAllBuckets(dpp, ¶ms);
params.op.bucket.info.bucket.name = bucketb;
db->ProcessOp(dpp, "RemoveBucket", ¶ms);
params.op.user.uinfo.user_id.id = user2;
db->ProcessOp(dpp, "RemoveUser", ¶ms);
db->ListAllUsers(dpp, ¶ms);
db->ListAllBuckets(dpp, ¶ms);
cout<<"Exiting thread:"<<thr_id<<"\n";
return 0;
}
int main(int argc, char *argv[])
{
string tenant = "Redhat";
string logfile = "rgw_dbstore_bin.log";
int loglevel = 20;
DBStoreManager *dbsm;
DB *dbs;
int rc = 0, tnum = 0;
void *res;
pthread_attr_t attr;
int num_thr = 2;
pthread_t threads[num_thr];
struct thr_args t_args[num_thr];
cout << "loglevel " << loglevel << "\n";
// format: ./dbstore-bin logfile loglevel
if (argc == 3) {
logfile = argv[1];
loglevel = (atoi)(argv[2]);
cout << "loglevel set to " << loglevel << "\n";
}
vector<const char*> args;
auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_DAEMON, CINIT_FLAG_NO_MON_CONFIG, 1);
dbsm = new DBStoreManager(cct.get(), logfile, loglevel);
dbs = dbsm->getDB(tenant, true);
cout<<"No. of threads being created = "<<num_thr<<"\n";
/* Initialize thread creation attributes */
rc = pthread_attr_init(&attr);
if (rc != 0) {
cout<<" error in pthread_attr_init \n";
goto out;
}
for (tnum = 0; tnum < num_thr; tnum++) {
t_args[tnum].dbs = dbs;
t_args[tnum].thr_id = tnum;
rc = pthread_create((pthread_t*)&threads[tnum], &attr, &process,
&t_args[tnum]);
if (rc != 0) {
cout<<" error in pthread_create \n";
goto out;
}
cout<<"Created thread (thread-id:"<<tnum<<")\n";
}
/* Destroy the thread attributes object, since it is no
longer needed */
rc = pthread_attr_destroy(&attr);
if (rc != 0) {
cout<<"error in pthread_attr_destroy \n";
}
/* Now join with each thread, and display its returned value */
for (tnum = 0; tnum < num_thr; tnum++) {
rc = pthread_join(threads[tnum], &res);
if (rc != 0) {
cout<<"error in pthread_join \n";
} else {
cout<<"Joined with thread "<<tnum<<"\n";
}
}
out:
dbsm->destroyAllHandles();
return 0;
}
| 5,126 | 24.635 | 86 |
cc
|
null |
ceph-main/src/rgw/driver/dbstore/dbstore_mgr.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "dbstore_mgr.h"
#include "common/dbstore_log.h"
#include <filesystem>
static constexpr auto dout_subsys = ceph_subsys_rgw;
using namespace std;
/* Given a tenant, find and return the DBStore handle.
* If not found and 'create' set to true, create one
* and return
*/
DB *DBStoreManager::getDB (string tenant, bool create)
{
map<string, DB*>::iterator iter;
DB *dbs = nullptr;
pair<map<string, DB*>::iterator,bool> ret;
if (tenant.empty())
return default_db;
if (DBStoreHandles.empty())
goto not_found;
iter = DBStoreHandles.find(tenant);
if (iter != DBStoreHandles.end())
return iter->second;
not_found:
if (!create)
return nullptr;
dbs = createDB(tenant);
return dbs;
}
/* Create DBStore instance */
DB *DBStoreManager::createDB(std::string tenant) {
DB *dbs = nullptr;
pair<map<string, DB*>::iterator,bool> ret;
const auto& db_path = g_conf().get_val<std::string>("dbstore_db_dir");
const auto& db_name = g_conf().get_val<std::string>("dbstore_db_name_prefix") + "-" + tenant;
auto db_full_path = std::filesystem::path(db_path) / db_name;
ldout(cct, 0) << "DB initialization full db_path("<<db_full_path<<")" << dendl;
/* Create the handle */
#ifdef SQLITE_ENABLED
dbs = new SQLiteDB(db_full_path.string(), cct);
#else
dbs = new DB(db_full_path.string(), cct);
#endif
/* API is DB::Initialize(string logfile, int loglevel);
* If none provided, by default write in to dbstore.log file
* created in current working directory with loglevel L_EVENT.
* XXX: need to align these logs to ceph location
*/
if (dbs->Initialize("", -1) < 0) {
ldout(cct, 0) << "DB initialization failed for tenant("<<tenant<<")" << dendl;
delete dbs;
return nullptr;
}
/* XXX: Do we need lock to protect this map?
*/
ret = DBStoreHandles.insert(pair<string, DB*>(tenant, dbs));
/*
* Its safe to check for already existing entry (just
* incase other thread raced and created the entry)
*/
if (ret.second == false) {
/* Entry already created by another thread */
delete dbs;
dbs = ret.first->second;
}
return dbs;
}
void DBStoreManager::deleteDB(string tenant) {
map<string, DB*>::iterator iter;
DB *dbs = nullptr;
if (tenant.empty() || DBStoreHandles.empty())
return;
/* XXX: Check if we need to perform this operation under a lock */
iter = DBStoreHandles.find(tenant);
if (iter == DBStoreHandles.end())
return;
dbs = iter->second;
DBStoreHandles.erase(iter);
dbs->Destroy(dbs->get_def_dpp());
delete dbs;
return;
}
void DBStoreManager::deleteDB(DB *dbs) {
if (!dbs)
return;
(void)deleteDB(dbs->getDBname());
}
void DBStoreManager::destroyAllHandles(){
map<string, DB*>::iterator iter;
DB *dbs = nullptr;
if (DBStoreHandles.empty())
return;
for (iter = DBStoreHandles.begin(); iter != DBStoreHandles.end();
++iter) {
dbs = iter->second;
dbs->Destroy(dbs->get_def_dpp());
delete dbs;
}
DBStoreHandles.clear();
return;
}
| 3,136 | 21.248227 | 95 |
cc
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.