// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
-// vim: ts=8 sw=2 smarttab
+// vim: ts=8 sw=2 smarttab ft=cpp
#include "common/ceph_json.h"
#include "rgw_op.h"
#include "rgw_user.h"
#include "rgw_rest_user.h"
+#include "rgw_sal.h"
#include "include/str_list.h"
-#include "include/assert.h"
+#include "include/ceph_assert.h"
+
+#include "services/svc_zone.h"
+#include "services/svc_sys_obj.h"
+#include "rgw_zone.h"
#define dout_subsys ceph_subsys_rgw
+using namespace std;
+
+class RGWOp_User_List : public RGWRESTOp {
+
+public:
+ RGWOp_User_List() {}
+
+ int check_caps(const RGWUserCaps& caps) override {
+ return caps.check_cap("users", RGW_CAP_READ);
+ }
+
+ void execute(optional_yield y) override;
+
+ const char* name() const override { return "list_user"; }
+};
+
+void RGWOp_User_List::execute(optional_yield y)
+{
+ RGWUserAdminOpState op_state(store);
+
+ uint32_t max_entries;
+ std::string marker;
+ RESTArgs::get_uint32(s, "max-entries", 1000, &max_entries);
+ RESTArgs::get_string(s, "marker", marker, &marker);
+
+ op_state.max_entries = max_entries;
+ op_state.marker = marker;
+ op_ret = RGWUserAdminOp_User::list(this, store, op_state, flusher);
+}
+
class RGWOp_User_Info : public RGWRESTOp {
public:
RGWOp_User_Info() {}
- int check_caps(RGWUserCaps& caps) override {
+ int check_caps(const RGWUserCaps& caps) override {
return caps.check_cap("users", RGW_CAP_READ);
}
- void execute() override;
+ void execute(optional_yield y) override;
- const string name() override { return "get_user_info"; }
+ const char* name() const override { return "get_user_info"; }
};
-void RGWOp_User_Info::execute()
+void RGWOp_User_Info::execute(optional_yield y)
{
- RGWUserAdminOpState op_state;
+ RGWUserAdminOpState op_state(store);
- std::string uid_str;
+ std::string uid_str, access_key_str;
bool fetch_stats;
bool sync_stats;
RESTArgs::get_string(s, "uid", uid_str, &uid_str);
+ RESTArgs::get_string(s, "access-key", access_key_str, &access_key_str);
// if uid was not supplied in rest argument, error out now, otherwise we'll
// end up initializing anonymous user, for which keys.init will eventually
// return -EACESS
- if (uid_str.empty()){
- http_ret=-EINVAL;
+ if (uid_str.empty() && access_key_str.empty()){
+ op_ret=-EINVAL;
return;
}
RESTArgs::get_bool(s, "sync", false, &sync_stats);
op_state.set_user_id(uid);
+ op_state.set_access_key(access_key_str);
op_state.set_fetch_stats(fetch_stats);
op_state.set_sync_stats(sync_stats);
- http_ret = RGWUserAdminOp_User::info(store, op_state, flusher);
+ op_ret = RGWUserAdminOp_User::info(s, store, op_state, flusher, y);
}
class RGWOp_User_Create : public RGWRESTOp {
public:
RGWOp_User_Create() {}
- int check_caps(RGWUserCaps& caps) override {
+ int check_caps(const RGWUserCaps& caps) override {
return caps.check_cap("users", RGW_CAP_WRITE);
}
- void execute() override;
+ void execute(optional_yield y) override;
- const string name() override { return "create_user"; }
+ const char* name() const override { return "create_user"; }
};
-void RGWOp_User_Create::execute()
+void RGWOp_User_Create::execute(optional_yield y)
{
std::string uid_str;
std::string display_name;
std::string key_type_str;
std::string caps;
std::string tenant_name;
+ std::string op_mask_str;
+ std::string default_placement_str;
+ std::string placement_tags_str;
bool gen_key;
bool suspended;
bool exclusive;
int32_t max_buckets;
- int32_t default_max_buckets = s->cct->_conf->rgw_user_max_buckets;
+ const int32_t default_max_buckets =
+ s->cct->_conf.get_val<int64_t>("rgw_user_max_buckets");
- RGWUserAdminOpState op_state;
+ RGWUserAdminOpState op_state(store);
RESTArgs::get_string(s, "uid", uid_str, &uid_str);
rgw_user uid(uid_str);
RESTArgs::get_int32(s, "max-buckets", default_max_buckets, &max_buckets);
RESTArgs::get_bool(s, "system", false, &system);
RESTArgs::get_bool(s, "exclusive", false, &exclusive);
+ RESTArgs::get_string(s, "op-mask", op_mask_str, &op_mask_str);
+ RESTArgs::get_string(s, "default-placement", default_placement_str, &default_placement_str);
+ RESTArgs::get_string(s, "placement-tags", placement_tags_str, &placement_tags_str);
- if (!s->user->system && system) {
- ldout(s->cct, 0) << "cannot set system flag by non-system user" << dendl;
- http_ret = -EINVAL;
+ if (!s->user->get_info().system && system) {
+ ldpp_dout(this, 0) << "cannot set system flag by non-system user" << dendl;
+ op_ret = -EINVAL;
return;
}
op_state.set_access_key(access_key);
op_state.set_secret_key(secret_key);
+ if (!op_mask_str.empty()) {
+ uint32_t op_mask;
+ int ret = rgw_parse_op_type_list(op_mask_str, &op_mask);
+ if (ret < 0) {
+ ldpp_dout(this, 0) << "failed to parse op_mask: " << ret << dendl;
+ op_ret = -EINVAL;
+ return;
+ }
+ op_state.set_op_mask(op_mask);
+ }
+
if (!key_type_str.empty()) {
int32_t key_type = KEY_TYPE_UNDEFINED;
if (key_type_str.compare("swift") == 0)
op_state.set_key_type(key_type);
}
- if (max_buckets != default_max_buckets)
+ if (max_buckets != default_max_buckets) {
+ if (max_buckets < 0) {
+ max_buckets = -1;
+ }
op_state.set_max_buckets(max_buckets);
-
+ }
if (s->info.args.exists("suspended"))
op_state.set_suspension(suspended);
if (gen_key)
op_state.set_generate_key();
- RGWQuotaInfo bucket_quota;
- RGWQuotaInfo user_quota;
-
- if (s->cct->_conf->rgw_bucket_default_quota_max_objects >= 0) {
- bucket_quota.max_objects = s->cct->_conf->rgw_bucket_default_quota_max_objects;
- bucket_quota.enabled = true;
- }
-
- if (s->cct->_conf->rgw_bucket_default_quota_max_size >= 0) {
- bucket_quota.max_size = s->cct->_conf->rgw_bucket_default_quota_max_size;
- bucket_quota.enabled = true;
- }
-
- if (s->cct->_conf->rgw_user_default_quota_max_objects >= 0) {
- user_quota.max_objects = s->cct->_conf->rgw_user_default_quota_max_objects;
- user_quota.enabled = true;
- }
-
- if (s->cct->_conf->rgw_user_default_quota_max_size >= 0) {
- user_quota.max_size = s->cct->_conf->rgw_user_default_quota_max_size;
- user_quota.enabled = true;
+ if (!default_placement_str.empty()) {
+ rgw_placement_rule target_rule;
+ target_rule.from_str(default_placement_str);
+ if (!store->get_zone()->get_params().valid_placement(target_rule)) {
+ ldpp_dout(this, 0) << "NOTICE: invalid dest placement: " << target_rule.to_str() << dendl;
+ op_ret = -EINVAL;
+ return;
+ }
+ op_state.set_default_placement(target_rule);
}
- if (bucket_quota.enabled) {
- op_state.set_bucket_quota(bucket_quota);
+ if (!placement_tags_str.empty()) {
+ list<string> placement_tags_list;
+ get_str_list(placement_tags_str, ",", placement_tags_list);
+ op_state.set_placement_tags(placement_tags_list);
}
- if (user_quota.enabled) {
- op_state.set_user_quota(user_quota);
+ bufferlist data;
+ op_ret = store->forward_request_to_master(s, s->user.get(), nullptr, data, nullptr, s->info, y);
+ if (op_ret < 0) {
+ ldpp_dout(this, 0) << "forward_request_to_master returned ret=" << op_ret << dendl;
+ return;
}
-
- http_ret = RGWUserAdminOp_User::create(store, op_state, flusher);
+ op_ret = RGWUserAdminOp_User::create(s, store, op_state, flusher, y);
}
class RGWOp_User_Modify : public RGWRESTOp {
public:
RGWOp_User_Modify() {}
- int check_caps(RGWUserCaps& caps) override {
+ int check_caps(const RGWUserCaps& caps) override {
return caps.check_cap("users", RGW_CAP_WRITE);
}
- void execute() override;
+ void execute(optional_yield y) override;
- const string name() override { return "modify_user"; }
+ const char* name() const override { return "modify_user"; }
};
-void RGWOp_User_Modify::execute()
+void RGWOp_User_Modify::execute(optional_yield y)
{
std::string uid_str;
std::string display_name;
std::string access_key;
std::string secret_key;
std::string key_type_str;
- std::string caps;
+ std::string op_mask_str;
+ std::string default_placement_str;
+ std::string placement_tags_str;
bool gen_key;
bool suspended;
bool system;
-
+ bool email_set;
+ bool quota_set;
int32_t max_buckets;
- RGWUserAdminOpState op_state;
+ RGWUserAdminOpState op_state(store);
RESTArgs::get_string(s, "uid", uid_str, &uid_str);
rgw_user uid(uid_str);
RESTArgs::get_string(s, "display-name", display_name, &display_name);
- RESTArgs::get_string(s, "email", email, &email);
+ RESTArgs::get_string(s, "email", email, &email, &email_set);
RESTArgs::get_string(s, "access-key", access_key, &access_key);
RESTArgs::get_string(s, "secret-key", secret_key, &secret_key);
- RESTArgs::get_string(s, "user-caps", caps, &caps);
RESTArgs::get_bool(s, "generate-key", false, &gen_key);
RESTArgs::get_bool(s, "suspended", false, &suspended);
- RESTArgs::get_int32(s, "max-buckets", RGW_DEFAULT_MAX_BUCKETS, &max_buckets);
+ RESTArgs::get_int32(s, "max-buckets", RGW_DEFAULT_MAX_BUCKETS, &max_buckets, "a_set);
RESTArgs::get_string(s, "key-type", key_type_str, &key_type_str);
RESTArgs::get_bool(s, "system", false, &system);
+ RESTArgs::get_string(s, "op-mask", op_mask_str, &op_mask_str);
+ RESTArgs::get_string(s, "default-placement", default_placement_str, &default_placement_str);
+ RESTArgs::get_string(s, "placement-tags", placement_tags_str, &placement_tags_str);
- if (!s->user->system && system) {
- ldout(s->cct, 0) << "cannot set system flag by non-system user" << dendl;
- http_ret = -EINVAL;
+ if (!s->user->get_info().system && system) {
+ ldpp_dout(this, 0) << "cannot set system flag by non-system user" << dendl;
+ op_ret = -EINVAL;
return;
}
op_state.set_user_id(uid);
op_state.set_display_name(display_name);
- op_state.set_user_email(email);
- op_state.set_caps(caps);
+
+ if (email_set)
+ op_state.set_user_email(email);
+
op_state.set_access_key(access_key);
op_state.set_secret_key(secret_key);
- if (max_buckets != RGW_DEFAULT_MAX_BUCKETS)
+ if (quota_set) {
+ if (max_buckets < 0 ) {
+ max_buckets = -1;
+ }
op_state.set_max_buckets(max_buckets);
-
+ }
if (gen_key)
op_state.set_generate_key();
op_state.set_key_type(key_type);
}
+ if (!op_mask_str.empty()) {
+ uint32_t op_mask;
+ if (rgw_parse_op_type_list(op_mask_str, &op_mask) < 0) {
+ ldpp_dout(this, 0) << "failed to parse op_mask" << dendl;
+ op_ret = -EINVAL;
+ return;
+ }
+ op_state.set_op_mask(op_mask);
+ }
+
if (s->info.args.exists("suspended"))
op_state.set_suspension(suspended);
if (s->info.args.exists("system"))
op_state.set_system(system);
- http_ret = RGWUserAdminOp_User::modify(store, op_state, flusher);
+ if (!op_mask_str.empty()) {
+ uint32_t op_mask;
+ int ret = rgw_parse_op_type_list(op_mask_str, &op_mask);
+ if (ret < 0) {
+ ldpp_dout(this, 0) << "failed to parse op_mask: " << ret << dendl;
+ op_ret = -EINVAL;
+ return;
+ }
+ op_state.set_op_mask(op_mask);
+ }
+
+ if (!default_placement_str.empty()) {
+ rgw_placement_rule target_rule;
+ target_rule.from_str(default_placement_str);
+ if (!store->get_zone()->get_params().valid_placement(target_rule)) {
+ ldpp_dout(this, 0) << "NOTICE: invalid dest placement: " << target_rule.to_str() << dendl;
+ op_ret = -EINVAL;
+ return;
+ }
+ op_state.set_default_placement(target_rule);
+ }
+
+ if (!placement_tags_str.empty()) {
+ list<string> placement_tags_list;
+ get_str_list(placement_tags_str, ",", placement_tags_list);
+ op_state.set_placement_tags(placement_tags_list);
+ }
+
+ bufferlist data;
+ op_ret = store->forward_request_to_master(s, s->user.get(), nullptr, data, nullptr, s->info, y);
+ if (op_ret < 0) {
+ ldpp_dout(this, 0) << "forward_request_to_master returned ret=" << op_ret << dendl;
+ return;
+ }
+ op_ret = RGWUserAdminOp_User::modify(s, store, op_state, flusher, y);
}
class RGWOp_User_Remove : public RGWRESTOp {
public:
RGWOp_User_Remove() {}
- int check_caps(RGWUserCaps& caps) override {
+ int check_caps(const RGWUserCaps& caps) override {
return caps.check_cap("users", RGW_CAP_WRITE);
}
- void execute() override;
+ void execute(optional_yield y) override;
- const string name() override { return "remove_user"; }
+ const char* name() const override { return "remove_user"; }
};
-void RGWOp_User_Remove::execute()
+void RGWOp_User_Remove::execute(optional_yield y)
{
std::string uid_str;
bool purge_data;
- RGWUserAdminOpState op_state;
+ RGWUserAdminOpState op_state(store);
RESTArgs::get_string(s, "uid", uid_str, &uid_str);
rgw_user uid(uid_str);
op_state.set_purge_data(purge_data);
- http_ret = RGWUserAdminOp_User::remove(store, op_state, flusher);
+ bufferlist data;
+ op_ret = store->forward_request_to_master(s, s->user.get(), nullptr, data, nullptr, s->info, y);
+ if (op_ret < 0) {
+ ldpp_dout(this, 0) << "forward_request_to_master returned ret=" << op_ret << dendl;
+ return;
+ }
+ op_ret = RGWUserAdminOp_User::remove(s, store, op_state, flusher, s->yield);
}
class RGWOp_Subuser_Create : public RGWRESTOp {
public:
RGWOp_Subuser_Create() {}
- int check_caps(RGWUserCaps& caps) override {
+ int check_caps(const RGWUserCaps& caps) override {
return caps.check_cap("users", RGW_CAP_WRITE);
}
- void execute() override;
+ void execute(optional_yield y) override;
- const string name() override { return "create_subuser"; }
+ const char* name() const override { return "create_subuser"; }
};
-void RGWOp_Subuser_Create::execute()
+void RGWOp_Subuser_Create::execute(optional_yield y)
{
std::string uid_str;
std::string subuser;
uint32_t perm_mask = 0;
int32_t key_type = KEY_TYPE_SWIFT;
- RGWUserAdminOpState op_state;
+ RGWUserAdminOpState op_state(store);
RESTArgs::get_string(s, "uid", uid_str, &uid_str);
rgw_user uid(uid_str);
RESTArgs::get_string(s, "secret-key", secret_key, &secret_key);
RESTArgs::get_string(s, "access", perm_str, &perm_str);
RESTArgs::get_string(s, "key-type", key_type_str, &key_type_str);
- //RESTArgs::get_bool(s, "generate-subuser", false, &gen_subuser);
RESTArgs::get_bool(s, "generate-secret", false, &gen_secret);
RESTArgs::get_bool(s, "gen-access-key", false, &gen_access);
}
op_state.set_key_type(key_type);
- http_ret = RGWUserAdminOp_Subuser::create(store, op_state, flusher);
+ bufferlist data;
+ op_ret = store->forward_request_to_master(s, s->user.get(), nullptr, data, nullptr, s->info, y);
+ if (op_ret < 0) {
+ ldpp_dout(this, 0) << "forward_request_to_master returned ret=" << op_ret << dendl;
+ return;
+ }
+ op_ret = RGWUserAdminOp_Subuser::create(s, store, op_state, flusher, y);
}
class RGWOp_Subuser_Modify : public RGWRESTOp {
public:
RGWOp_Subuser_Modify() {}
- int check_caps(RGWUserCaps& caps) override {
+ int check_caps(const RGWUserCaps& caps) override {
return caps.check_cap("users", RGW_CAP_WRITE);
}
- void execute() override;
+ void execute(optional_yield y) override;
- const string name() override { return "modify_subuser"; }
+ const char* name() const override { return "modify_subuser"; }
};
-void RGWOp_Subuser_Modify::execute()
+void RGWOp_Subuser_Modify::execute(optional_yield y)
{
std::string uid_str;
std::string subuser;
std::string key_type_str;
std::string perm_str;
- RGWUserAdminOpState op_state;
+ RGWUserAdminOpState op_state(store);
uint32_t perm_mask;
int32_t key_type = KEY_TYPE_SWIFT;
}
op_state.set_key_type(key_type);
- http_ret = RGWUserAdminOp_Subuser::modify(store, op_state, flusher);
+ bufferlist data;
+ op_ret = store->forward_request_to_master(s, s->user.get(), nullptr, data, nullptr, s->info, y);
+ if (op_ret < 0) {
+ ldpp_dout(this, 0) << "forward_request_to_master returned ret=" << op_ret << dendl;
+ return;
+ }
+ op_ret = RGWUserAdminOp_Subuser::modify(s, store, op_state, flusher, y);
}
class RGWOp_Subuser_Remove : public RGWRESTOp {
public:
RGWOp_Subuser_Remove() {}
- int check_caps(RGWUserCaps& caps) override {
+ int check_caps(const RGWUserCaps& caps) override {
return caps.check_cap("users", RGW_CAP_WRITE);
}
- void execute() override;
+ void execute(optional_yield y) override;
- const string name() override { return "remove_subuser"; }
+ const char* name() const override { return "remove_subuser"; }
};
-void RGWOp_Subuser_Remove::execute()
+void RGWOp_Subuser_Remove::execute(optional_yield y)
{
std::string uid_str;
std::string subuser;
bool purge_keys;
- RGWUserAdminOpState op_state;
+ RGWUserAdminOpState op_state(store);
RESTArgs::get_string(s, "uid", uid_str, &uid_str);
rgw_user uid(uid_str);
if (purge_keys)
op_state.set_purge_keys();
- http_ret = RGWUserAdminOp_Subuser::remove(store, op_state, flusher);
+ bufferlist data;
+ op_ret = store->forward_request_to_master(s, s->user.get(), nullptr, data, nullptr, s->info, y);
+ if (op_ret < 0) {
+ ldpp_dout(this, 0) << "forward_request_to_master returned ret=" << op_ret << dendl;
+ return;
+ }
+ op_ret = RGWUserAdminOp_Subuser::remove(s, store, op_state, flusher, y);
}
class RGWOp_Key_Create : public RGWRESTOp {
public:
RGWOp_Key_Create() {}
- int check_caps(RGWUserCaps& caps) override {
+ int check_caps(const RGWUserCaps& caps) override {
return caps.check_cap("users", RGW_CAP_WRITE);
}
- void execute() override;
+ void execute(optional_yield y) override;
- const string name() override { return "create_access_key"; }
+ const char* name() const override { return "create_access_key"; }
};
-void RGWOp_Key_Create::execute()
+void RGWOp_Key_Create::execute(optional_yield y)
{
std::string uid_str;
std::string subuser;
bool gen_key;
- RGWUserAdminOpState op_state;
+ RGWUserAdminOpState op_state(store);
RESTArgs::get_string(s, "uid", uid_str, &uid_str);
rgw_user uid(uid_str);
op_state.set_key_type(key_type);
}
- http_ret = RGWUserAdminOp_Key::create(store, op_state, flusher);
+ op_ret = RGWUserAdminOp_Key::create(s, store, op_state, flusher, y);
}
class RGWOp_Key_Remove : public RGWRESTOp {
public:
RGWOp_Key_Remove() {}
- int check_caps(RGWUserCaps& caps) override {
+ int check_caps(const RGWUserCaps& caps) override {
return caps.check_cap("users", RGW_CAP_WRITE);
}
- void execute() override;
+ void execute(optional_yield y) override;
- const string name() override { return "remove_access_key"; }
+ const char* name() const override { return "remove_access_key"; }
};
-void RGWOp_Key_Remove::execute()
+void RGWOp_Key_Remove::execute(optional_yield y)
{
std::string uid_str;
std::string subuser;
std::string access_key;
std::string key_type_str;
- RGWUserAdminOpState op_state;
+ RGWUserAdminOpState op_state(store);
RESTArgs::get_string(s, "uid", uid_str, &uid_str);
rgw_user uid(uid_str);
op_state.set_key_type(key_type);
}
- http_ret = RGWUserAdminOp_Key::remove(store, op_state, flusher);
+ op_ret = RGWUserAdminOp_Key::remove(s, store, op_state, flusher, y);
}
class RGWOp_Caps_Add : public RGWRESTOp {
public:
RGWOp_Caps_Add() {}
- int check_caps(RGWUserCaps& caps) override {
+ int check_caps(const RGWUserCaps& caps) override {
return caps.check_cap("users", RGW_CAP_WRITE);
}
- void execute() override;
+ void execute(optional_yield y) override;
- const string name() override { return "add_user_caps"; }
+ const char* name() const override { return "add_user_caps"; }
};
-void RGWOp_Caps_Add::execute()
+void RGWOp_Caps_Add::execute(optional_yield y)
{
std::string uid_str;
std::string caps;
- RGWUserAdminOpState op_state;
+ RGWUserAdminOpState op_state(store);
RESTArgs::get_string(s, "uid", uid_str, &uid_str);
rgw_user uid(uid_str);
op_state.set_user_id(uid);
op_state.set_caps(caps);
- http_ret = RGWUserAdminOp_Caps::add(store, op_state, flusher);
+ bufferlist data;
+ op_ret = store->forward_request_to_master(s, s->user.get(), nullptr, data, nullptr, s->info, y);
+ if (op_ret < 0) {
+ ldpp_dout(this, 0) << "forward_request_to_master returned ret=" << op_ret << dendl;
+ return;
+ }
+ op_ret = RGWUserAdminOp_Caps::add(s, store, op_state, flusher, y);
}
class RGWOp_Caps_Remove : public RGWRESTOp {
public:
RGWOp_Caps_Remove() {}
- int check_caps(RGWUserCaps& caps) override {
+ int check_caps(const RGWUserCaps& caps) override {
return caps.check_cap("users", RGW_CAP_WRITE);
}
- void execute() override;
+ void execute(optional_yield y) override;
- const string name() override { return "remove_user_caps"; }
+ const char* name() const override { return "remove_user_caps"; }
};
-void RGWOp_Caps_Remove::execute()
+void RGWOp_Caps_Remove::execute(optional_yield y)
{
std::string uid_str;
std::string caps;
- RGWUserAdminOpState op_state;
+ RGWUserAdminOpState op_state(store);
RESTArgs::get_string(s, "uid", uid_str, &uid_str);
rgw_user uid(uid_str);
op_state.set_user_id(uid);
op_state.set_caps(caps);
- http_ret = RGWUserAdminOp_Caps::remove(store, op_state, flusher);
+ bufferlist data;
+ op_ret = store->forward_request_to_master(s, s->user.get(), nullptr, data, nullptr, s->info, y);
+ if (op_ret < 0) {
+ ldpp_dout(this, 0) << "forward_request_to_master returned ret=" << op_ret << dendl;
+ return;
+ }
+ op_ret = RGWUserAdminOp_Caps::remove(s, store, op_state, flusher, y);
}
struct UserQuotas {
UserQuotas() {}
- explicit UserQuotas(RGWUserInfo& info) : bucket_quota(info.bucket_quota),
+ explicit UserQuotas(RGWUserInfo& info) : bucket_quota(info.bucket_quota),
user_quota(info.user_quota) {}
void dump(Formatter *f) const {
public:
RGWOp_Quota_Info() {}
- int check_caps(RGWUserCaps& caps) override {
+ int check_caps(const RGWUserCaps& caps) override {
return caps.check_cap("users", RGW_CAP_READ);
}
- void execute() override;
+ void execute(optional_yield y) override;
- const string name() override { return "get_quota_info"; }
+ const char* name() const override { return "get_quota_info"; }
};
-void RGWOp_Quota_Info::execute()
+void RGWOp_Quota_Info::execute(optional_yield y)
{
- RGWUserAdminOpState op_state;
+ RGWUserAdminOpState op_state(store);
std::string uid_str;
std::string quota_type;
RESTArgs::get_string(s, "quota-type", quota_type, "a_type);
if (uid_str.empty()) {
- http_ret = -EINVAL;
+ op_ret = -EINVAL;
return;
}
bool show_user = show_all || (quota_type == "user");
if (!(show_all || show_bucket || show_user)) {
- http_ret = -EINVAL;
+ op_ret = -EINVAL;
return;
}
op_state.set_user_id(uid);
RGWUser user;
- http_ret = user.init(store, op_state);
- if (http_ret < 0)
+ op_ret = user.init(s, store, op_state, y);
+ if (op_ret < 0)
return;
if (!op_state.has_existing_user()) {
- http_ret = -ERR_NO_SUCH_USER;
+ op_ret = -ERR_NO_SUCH_USER;
return;
}
RGWUserInfo info;
string err_msg;
- http_ret = user.info(info, &err_msg);
- if (http_ret < 0)
+ op_ret = user.info(info, &err_msg);
+ if (op_ret < 0)
return;
flusher.start(0);
public:
RGWOp_Quota_Set() {}
- int check_caps(RGWUserCaps& caps) override {
+ int check_caps(const RGWUserCaps& caps) override {
return caps.check_cap("users", RGW_CAP_WRITE);
}
- void execute() override;
+ void execute(optional_yield y) override;
- const string name() override { return "set_quota_info"; }
+ const char* name() const override { return "set_quota_info"; }
};
/**
*
*/
-void RGWOp_Quota_Set::execute()
+void RGWOp_Quota_Set::execute(optional_yield y)
{
- RGWUserAdminOpState op_state;
+ RGWUserAdminOpState op_state(store);
std::string uid_str;
std::string quota_type;
RESTArgs::get_string(s, "quota-type", quota_type, "a_type);
if (uid_str.empty()) {
- http_ret = -EINVAL;
+ op_ret = -EINVAL;
return;
}
bool set_user = set_all || (quota_type == "user");
if (!(set_all || set_bucket || set_user)) {
- ldout(store->ctx(), 20) << "invalid quota type" << dendl;
- http_ret = -EINVAL;
+ ldpp_dout(this, 20) << "invalid quota type" << dendl;
+ op_ret = -EINVAL;
return;
}
}
if (use_http_params && set_all) {
- ldout(store->ctx(), 20) << "quota type was not specified, can't set all quotas via http headers" << dendl;
- http_ret = -EINVAL;
+ ldpp_dout(this, 20) << "quota type was not specified, can't set all quotas via http headers" << dendl;
+ op_ret = -EINVAL;
return;
}
op_state.set_user_id(uid);
RGWUser user;
- http_ret = user.init(store, op_state);
- if (http_ret < 0) {
- ldout(store->ctx(), 20) << "failed initializing user info: " << http_ret << dendl;
+ op_ret = user.init(s, store, op_state, y);
+ if (op_ret < 0) {
+ ldpp_dout(this, 20) << "failed initializing user info: " << op_ret << dendl;
return;
}
if (!op_state.has_existing_user()) {
- http_ret = -ERR_NO_SUCH_USER;
+ op_ret = -ERR_NO_SUCH_USER;
return;
}
if (set_all) {
UserQuotas quotas;
- if ((http_ret = rgw_rest_get_json_input(store->ctx(), s, quotas, QUOTA_INPUT_MAX_LEN, NULL)) < 0) {
- ldout(store->ctx(), 20) << "failed to retrieve input" << dendl;
+ if ((op_ret = get_json_input(store->ctx(), s, quotas, QUOTA_INPUT_MAX_LEN, NULL)) < 0) {
+ ldpp_dout(this, 20) << "failed to retrieve input" << dendl;
return;
}
if (!use_http_params) {
bool empty;
- http_ret = rgw_rest_get_json_input(store->ctx(), s, quota, QUOTA_INPUT_MAX_LEN, &empty);
- if (http_ret < 0) {
- ldout(store->ctx(), 20) << "failed to retrieve input" << dendl;
+ op_ret = get_json_input(store->ctx(), s, quota, QUOTA_INPUT_MAX_LEN, &empty);
+ if (op_ret < 0) {
+ ldpp_dout(this, 20) << "failed to retrieve input" << dendl;
if (!empty)
return;
if (use_http_params) {
RGWUserInfo info;
string err_msg;
- http_ret = user.info(info, &err_msg);
- if (http_ret < 0) {
- ldout(store->ctx(), 20) << "failed to get user info: " << http_ret << dendl;
+ op_ret = user.info(info, &err_msg);
+ if (op_ret < 0) {
+ ldpp_dout(this, 20) << "failed to get user info: " << op_ret << dendl;
return;
}
RGWQuotaInfo *old_quota;
old_quota = &info.bucket_quota;
}
- int64_t old_max_size_kb = rgw_rounded_kb(old_quota->max_size);
- int64_t max_size_kb;
RESTArgs::get_int64(s, "max-objects", old_quota->max_objects, "a.max_objects);
- RESTArgs::get_int64(s, "max-size-kb", old_max_size_kb, &max_size_kb);
- quota.max_size = max_size_kb * 1024;
+ RESTArgs::get_int64(s, "max-size", old_quota->max_size, "a.max_size);
+ int64_t max_size_kb;
+ bool has_max_size_kb = false;
+ RESTArgs::get_int64(s, "max-size-kb", 0, &max_size_kb, &has_max_size_kb);
+ if (has_max_size_kb) {
+ quota.max_size = max_size_kb * 1024;
+ }
RESTArgs::get_bool(s, "enabled", old_quota->enabled, "a.enabled);
}
}
string err;
- http_ret = user.modify(op_state, &err);
- if (http_ret < 0) {
- ldout(store->ctx(), 20) << "failed updating user info: " << http_ret << ": " << err << dendl;
+ op_ret = user.modify(s, op_state, y, &err);
+ if (op_ret < 0) {
+ ldpp_dout(this, 20) << "failed updating user info: " << op_ret << ": " << err << dendl;
return;
}
}
if (s->info.args.sub_resource_exists("quota"))
return new RGWOp_Quota_Info;
+ if (s->info.args.sub_resource_exists("list"))
+ return new RGWOp_User_List;
+
return new RGWOp_User_Info;
}
projects / ceph.git / blobdiff