rgw_crypt_sanitize.cc
rgw_iam_policy.cc
rgw_rest_user_policy.cc
+ rgw_zone.cc
rgw_sts.cc
rgw_rest_sts.cc)
#include "rgw_process.h"
#include "rgw_rest_s3.h" // RGW_Auth_S3
#include "rgw_ldap.h"
+#include "services/svc_zone_utils.h"
#include "include/ceph_assert.h"
class OpsLogSocket;
RGWHandler::init(rados_ctx->store, _s, io);
get_state()->obj_ctx = rados_ctx;
- get_state()->req_id = store->unique_id(id);
- get_state()->trans_id = store->unique_trans_id(id);
+ get_state()->req_id = store->svc.zone_utils->unique_id(id);
+ get_state()->trans_id = store->svc.zone_utils->unique_trans_id(id);
ldpp_dout(_s, 2) << "initializing for trans_id = "
<< get_state()->trans_id.c_str() << dendl;
RGWHandler::init(rados_ctx.store, &rstate, &io_ctx);
get_state()->obj_ctx = &rados_ctx;
- get_state()->req_id = store->unique_id(id);
- get_state()->trans_id = store->unique_trans_id(id);
+ get_state()->req_id = store->svc.zone_utils->unique_id(id);
+ get_state()->trans_id = store->svc.zone_utils->unique_trans_id(id);
ldpp_dout(get_state(), 2) << "initializing for trans_id = "
<< get_state()->trans_id.c_str() << dendl;
#include "rgw_client_io.h"
#include "rgw_rest.h"
+#include "services/svc_zone.h"
+
#define dout_subsys ceph_subsys_rgw
static void set_param_str(struct req_state *s, const char *name, string& str)
string oid = render_log_object_name(s->cct->_conf->rgw_log_object_name, &bdt,
s->bucket.bucket_id, entry.bucket);
- rgw_raw_obj obj(store->get_zone_params().log_pool, oid);
+ rgw_raw_obj obj(store->svc.zone->get_zone_params().log_pool, oid);
ret = store->append_async(obj, bl.length(), bl);
if (ret == -ENOENT) {
- ret = store->create_pool(store->get_zone_params().log_pool);
+ ret = store->create_pool(store->svc.zone->get_zone_params().log_pool);
if (ret < 0)
goto done;
// retry
#include "rgw_asio_frontend.h"
#endif /* WITH_RADOSGW_BEAST_FRONTEND */
+#include "services/svc_zone.h"
+
#ifdef HAVE_SYS_PRCTL_H
#include <sys/prctl.h>
#endif
return -r;
}
- rgw_rest_init(g_ceph_context, store, store->get_zonegroup());
+ rgw_rest_init(g_ceph_context, store, store->svc.zone->get_zonegroup());
mutex.Lock();
init_timer.cancel_all_events();
set_logging(rest_filter(store, RGW_REST_SWIFT,
swift_resource)));
} else {
- if (store->get_zonegroup().zones.size() > 1) {
+ if (store->svc.zone->get_zonegroup().zones.size() > 1) {
derr << "Placing Swift API in the root of URL hierarchy while running"
<< " multi-site configuration requires another instance of RadosGW"
<< " with S3 API enabled!" << dendl;
RGWFrontendPauser pauser(fes, &pusher);
RGWRealmReloader reloader(store, service_map_meta, &pauser);
- RGWRealmWatcher realm_watcher(g_ceph_context, store->realm);
+ RGWRealmWatcher realm_watcher(g_ceph_context, store->svc.zone->get_realm());
realm_watcher.add_watcher(RGWRealmNotify::Reload, reloader);
realm_watcher.add_watcher(RGWRealmNotify::ZonesNeedPeriod, pusher);
#include "rgw_period_pusher.h"
#include "rgw_cr_rest.h"
+#include "rgw_zone.h"
+
+#include "services/svc_zone.h"
+
#include "common/errno.h"
+
#include <boost/asio/yield.hpp>
#define dout_subsys ceph_subsys_rgw
RGWPeriodPusher::RGWPeriodPusher(RGWRados* store)
: cct(store->ctx()), store(store)
{
- const auto& realm = store->realm;
+ const auto& realm = store->svc.zone->get_realm();
auto& realm_id = realm.get_id();
if (realm_id.empty()) // no realm configuration
return;
// always send out the current period on startup
RGWPeriod period;
- int r = period.init(cct, store, realm_id, realm.get_name());
+ int r = period.init(cct, store->svc.sysobj, realm_id, realm.get_name());
if (r < 0) {
lderr(cct) << "failed to load period for realm " << realm_id << dendl;
return;
// find our zonegroup in the new period
auto& zonegroups = period.get_map().zonegroups;
- auto i = zonegroups.find(store->get_zonegroup().get_id());
+ auto i = zonegroups.find(store->svc.zone->get_zonegroup().get_id());
if (i == zonegroups.end()) {
lderr(cct) << "The new period does not contain my zonegroup!" << dendl;
return;
auto& my_zonegroup = i->second;
// if we're not a master zone, we're not responsible for pushing any updates
- if (my_zonegroup.master_zone != store->get_zone_params().get_id())
+ if (my_zonegroup.master_zone != store->svc.zone->get_zone_params().get_id())
return;
// construct a map of the zones that need this period. the map uses the same
auto hint = conns.end();
// are we the master zonegroup in this period?
- if (period.get_map().master_zonegroup == store->get_zonegroup().get_id()) {
+ if (period.get_map().master_zonegroup == store->svc.zone->get_zonegroup().get_id()) {
// update other zonegroup endpoints
for (auto& zg : zonegroups) {
auto& zonegroup = zg.second;
- if (zonegroup.get_id() == store->get_zonegroup().get_id())
+ if (zonegroup.get_id() == store->svc.zone->get_zonegroup().get_id())
continue;
if (zonegroup.endpoints.empty())
continue;
hint = conns.emplace_hint(
hint, std::piecewise_construct,
std::forward_as_tuple(zonegroup.get_id()),
- std::forward_as_tuple(cct, store, zonegroup.get_id(), zonegroup.endpoints, RGWAccessKey()));
+ std::forward_as_tuple(cct, store->svc.zone, zonegroup.get_id(), zonegroup.endpoints, RGWAccessKey()));
}
}
// update other zone endpoints
for (auto& z : my_zonegroup.zones) {
auto& zone = z.second;
- if (zone.id == store->get_zone_params().get_id())
+ if (zone.id == store->svc.zone->get_zone_params().get_id())
continue;
if (zone.endpoints.empty())
continue;
hint = conns.emplace_hint(
hint, std::piecewise_construct,
std::forward_as_tuple(zone.id),
- std::forward_as_tuple(cct, store, zone.id, zone.endpoints));
+ std::forward_as_tuple(cct, store->svc.zone, zone.id, zone.endpoints));
}
if (conns.empty()) {
#include "rgw_client_io.h"
#include "rgw_opa.h"
+#include "services/svc_zone_utils.h"
+
#define dout_subsys ceph_subsys_rgw
void RGWProcess::RGWWQ::_dump_queue()
return ret;
}
- s->req_id = store->unique_id(req->id);
- s->trans_id = store->unique_trans_id(req->id);
+ s->req_id = store->svc.zone_utils->unique_id(req->id);
+ s->trans_id = store->svc.zone_utils->unique_trans_id(req->id);
s->host_id = store->host_id;
ldpp_dout(s, 2) << "initializing for trans_id = " << s->trans_id << dendl;
static string log_lock_name = "rgw_log_lock";
static RGWObjCategory main_category = RGW_OBJ_CATEGORY_MAIN;
#define RGW_USAGE_OBJ_PREFIX "usage."
-#define FIRST_EPOCH 1
#define dout_subsys ceph_subsys_rgw
#include "rgw_rest.h"
#include "rgw_user.h"
+#include "services/svc_zone.h"
+
#include "common/errno.h"
#define dout_subsys ceph_subsys_rgw
ldout(cct, 1) << "Finishing initialization of new store" << dendl;
// finish initializing the new store
ldout(cct, 1) << " - REST subsystem init" << dendl;
- rgw_rest_init(cct, store, store->get_zonegroup());
+ rgw_rest_init(cct, store, store->svc.zone->get_zonegroup());
ldout(cct, 1) << " - user subsystem init" << dendl;
rgw_user_init(store);
ldout(cct, 1) << " - user subsystem init" << dendl;
#include "rgw_realm_watcher.h"
#include "rgw_rados.h"
+#include "rgw_zone.h"
#define dout_subsys ceph_subsys_rgw
#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
void RGWOp_ZoneGroupMap_Get::execute() {
- http_ret = zonegroup_map.read(g_ceph_context, store);
+ http_ret = zonegroup_map.read(g_ceph_context, store->svc.sysobj);
if (http_ret < 0) {
dout(5) << "failed to read zone_group map" << dendl;
}
}
void RGWOp_ZoneConfig_Get::send_response() {
- const RGWZoneParams& zone_params = store->get_zone_params();
+ const RGWZoneParams& zone_params = store->svc.zone->get_zone_params();
set_req_state_err(s, http_ret);
dump_errno(s);
#include "rgw_request.h"
#include "rgw_process.h"
+#include "rgw_zone.h"
+
+#include "services/svc_zone.h"
+
#include <array>
#include <sstream>
#include <memory>
policy.create_default(s->user->user_id, s->user->display_name);
}
- location_constraint = store->get_zonegroup().api_name;
+ location_constraint = store->svc.zone->get_zonegroup().api_name;
get_rmattrs_from_headers(s, CONT_PUT_ATTR_PREFIX,
CONT_REMOVE_ATTR_PREFIX, rmattr_names);
placement_rule = s->info.env->get("HTTP_X_STORAGE_POLICY", "");
}
formatter.open_array_section("policies");
- RGWZoneGroup& zonegroup = store.get_zonegroup();
+ RGWZoneGroup& zonegroup = store.svc.zone->get_zonegroup();
for (const auto& placement_targets : zonegroup.placement_targets) {
formatter.open_object_section("policy");
+#include "common/errno.h"
+
#include "rgw_zone.h"
+#include "rgw_realm_watcher.h"
+#include "rgw_meta_sync_status.h"
+#include "services/svc_zone.h"
#include "services/svc_sys_obj.h"
+#define dout_subsys ceph_subsys_rgw
+
+namespace rgw_zone_defaults {
+
+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 realm_names_oid_prefix = "realms_names.";
+std::string zone_group_info_oid_prefix = "zonegroup_info.";
+std::string realm_info_oid_prefix = "realms.";
+std::string default_region_info_oid = "default.region";
+std::string default_zone_group_info_oid = "default.zonegroup";
+std::string period_info_oid_prefix = "periods.";
+std::string period_latest_epoch_info_oid = ".latest_epoch";
+std::string region_map_oid = "region_map";
+std::string default_realm_info_oid = "default.realm";
+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_REALM_ROOT_POOL = "rgw.root";
+std::string RGW_DEFAULT_PERIOD_ROOT_POOL = "rgw.root";
+std::string default_bucket_index_pool_suffix = "rgw.buckets.index";
+std::string default_storage_extra_pool_suffix = "rgw.buckets.non-ec";
+std::string avail_pools = ".pools.avail";
+std::string default_storage_pool_suffix = "rgw.buckets.data";
+
+}
+
+using namespace rgw_zone_defaults;
+
+#define FIRST_EPOCH 1
+
void RGWDefaultZoneGroupInfo::dump(Formatter *f) const {
encode_json("default_zonegroup", default_zonegroup, f);
}
RGWZoneParams zone_params(default_zone_name);
- int r = zone_params.init(cct, zone_svc, false);
+ int r = zone_params.init(cct, sysobj_svc, false);
if (r < 0) {
ldout(cct, 0) << "create_default: error initializing zone params: " << cpp_strerror(-r) << dendl;
return r;
} else if (r == -EEXIST) {
ldout(cct, 10) << "zone_params::create_default() returned -EEXIST, we raced with another default zone_params creation" << dendl;
zone_params.clear_id();
- r = zone_params.init(cct, zone_svc);
+ r = zone_params.init(cct, sysobj_svc);
if (r < 0) {
ldout(cct, 0) << "create_default: error in init existing zone params: " << cpp_strerror(-r) << dendl;
return r;
if (r == -EEXIST) {
ldout(cct, 10) << "create_default() returned -EEXIST, we raced with another zonegroup creation" << dendl;
id.clear();
- r = init(cct, zone_svc);
+ r = init(cct, sysobj_svc);
if (r < 0) {
return r;
}
<< ", valid sync modules: "
<< store->get_sync_modules_manager()->get_registered_module_names()
<< dendl;
-#endif
return -ENOENT;
}
+#endif
}
if (psync_from_all) {
zone.log_data = log_data;
RGWZoneParams zone_params(zone.id, zone.name);
- int ret = zone_params.init(cct, zone_svc);
+ int ret = zone_params.init(cct, sysobj_svc);
if (ret < 0) {
ldout(cct, 0) << "WARNING: could not read zone params for zone id=" << zone.id << " name=" << zone.name << dendl;
continue;
if (realm_id.empty()) {
/* try using default realm */
RGWRealm realm;
- int ret = realm.init(cct, zone_svc);
+ int ret = realm.init(cct, sysobj_svc);
// no default realm exist
if (ret < 0) {
return read_id(default_zonegroup_name, default_id);
if (realm_id.empty()) {
/* try using default realm */
RGWRealm realm;
- int ret = realm.init(cct, zone_svc);
+ int ret = realm.init(cct, sysobj_svc);
if (ret < 0) {
ldout(cct, 10) << "could not read realm id: " << cpp_strerror(-ret) << dendl;
return -EINVAL;
return RGWSystemMetaObj::set_as_default(exclusive);
}
-int RGWSystemMetaObj::init(CephContext *_cct, RGWSI_Zone *_zone_svc, bool setup_obj, bool old_format)
+void RGWSystemMetaObj::reinit_instance(CephContext *_cct, RGWSI_SysObj *_sysobj_svc)
{
cct = _cct;
- zone_svc = _zone_svc;
+ sysobj_svc = _sysobj_svc;
+ zone_svc = _sysobj_svc->get_zone_svc();
+}
+
+int RGWSystemMetaObj::init(CephContext *_cct, RGWSI_SysObj *_sysobj_svc, bool setup_obj, bool old_format)
+{
+ reinit_instance(_cct, _sysobj_svc);
if (!setup_obj)
return 0;
using ceph::decode;
auto pool = get_pool(cct);
bufferlist bl;
- RGWSysObjectCtx obj_ctx = sysobj_svc->get_obj_ctx();
- int ret = rgw_get_system_obj(store, obj_ctx, pool, oid, bl, NULL, NULL);
+ auto obj_ctx = sysobj_svc->init_obj_ctx();
+ auto sysobj = sysobj_svc->get_obj(obj_ctx, rgw_raw_obj(pool, oid));
+ int ret = sysobj.rop().read(&bl);
if (ret < 0)
return ret;
encode(default_info, bl);
- int ret = rgw_put_system_obj(store, pool, oid, bl,
- exclusive, NULL, real_time(), NULL);
+ auto obj_ctx = sysobj_svc->init_obj_ctx();
+ auto sysobj = sysobj_svc->get_obj(obj_ctx, rgw_raw_obj(pool, oid));
+ int ret = sysobj.wop()
+ .set_exclusive(exclusive)
+ .write(bl);
if (ret < 0)
return ret;
string oid = get_names_oid_prefix() + obj_name;
- RGWSysObjectCtx obj_ctx = sysobj_svc->get_obj_ctx();
-
- int ret = rgw_get_system_obj(store, obj_ctx, pool, oid, bl, NULL, NULL);
+ auto obj_ctx = sysobj_svc->init_obj_ctx();
+ auto sysobj = sysobj_svc->get_obj(obj_ctx, rgw_raw_obj(pool, oid));
+ int ret = sysobj.rop().read(&bl);
if (ret < 0) {
return ret;
}
{
rgw_pool pool(get_pool(cct));
+ auto obj_ctx = sysobj_svc->init_obj_ctx();
+
/* check to see if obj is the default */
RGWDefaultSystemMetaObjInfo default_info;
int ret = read_default(default_info, get_default_oid(old_format));
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);
- ret = store->delete_system_obj(default_named_obj);
+ auto sysobj = sysobj_svc->get_obj(obj_ctx, default_named_obj);
+ ret = sysobj.wop().remove();
if (ret < 0) {
ldout(cct, 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);
- ret = store->delete_system_obj(object_name);
+ auto sysobj = sysobj_svc->get_obj(obj_ctx, object_name);
+ ret = sysobj.wop().remove();
if (ret < 0) {
ldout(cct, 0) << "Error delete obj name " << name << ": " << cpp_strerror(-ret) << dendl;
return ret;
}
rgw_raw_obj object_id(pool, oid);
- ret = store->delete_system_obj(object_id);
+ auto sysobj = sysobj_svc->get_obj(obj_ctx, object_id);
+ ret = sysobj.wop().remove();
if (ret < 0) {
ldout(cct, 0) << "Error delete object id " << id << ": " << cpp_strerror(-ret) << dendl;
}
bufferlist bl;
using ceph::encode;
encode(nameToId, bl);
- return rgw_put_system_obj(store, pool, oid, bl, exclusive, NULL, real_time(), NULL);
+ auto obj_ctx = sysobj_svc->init_obj_ctx();
+ auto sysobj = sysobj_svc->get_obj(obj_ctx, rgw_raw_obj(pool, oid));
+ return sysobj.wop()
+ .set_exclusive(exclusive)
+ .write(bl);
}
int RGWSystemMetaObj::rename(const string& new_name)
rgw_pool pool(get_pool(cct));
string oid = get_names_oid_prefix() + old_name;
rgw_raw_obj old_name_obj(pool, oid);
- ret = store->delete_system_obj(old_name_obj);
+ auto obj_ctx = sysobj_svc->init_obj_ctx();
+ auto sysobj = sysobj_svc->get_obj(obj_ctx, old_name_obj);
+ ret = sysobj.wop().remove();
if (ret < 0) {
ldout(cct, 0) << "Error delete old obj name " << old_name << ": " << cpp_strerror(-ret) << dendl;
return ret;
string oid = get_info_oid_prefix(old_format) + obj_id;
- RGWSysObjectCtx obj_ctx = sysobj_svc->get_obj_ctx();
-
- int ret = rgw_get_system_obj(store, obj_ctx, pool, oid, bl, NULL, NULL);
+ auto obj_ctx = sysobj_svc->init_obj_ctx();
+ auto sysobj = sysobj_svc->get_obj(obj_ctx, rgw_raw_obj{pool, oid});
+ int ret = sysobj.rop().read(&bl);
if (ret < 0) {
ldout(cct, 0) << "failed reading obj info from " << pool << ":" << oid << ": " << cpp_strerror(-ret) << dendl;
return ret;
bufferlist bl;
using ceph::encode;
encode(*this, bl);
- return rgw_put_system_obj(store, pool, oid, bl, exclusive, NULL, real_time(), NULL);
+ auto obj_ctx = sysobj_svc->init_obj_ctx();
+ auto sysobj = sysobj_svc->get_obj(obj_ctx, rgw_raw_obj{pool, oid});
+ return sysobj.wop()
+ .set_exclusive(exclusive)
+ .write(bl);
}
int RGWSystemMetaObj::write(bool exclusive)
RGWPeriod period;
if (current_period.empty()) {
/* create new period for the realm */
- ret = period.init(cct, store, id, name, false);
+ ret = period.init(cct, sysobj_svc, id, name, false);
if (ret < 0 ) {
return ret;
}
}
} else {
period = RGWPeriod(current_period, 0);
- int ret = period.init(cct, store, id, name);
+ int ret = period.init(cct, sysobj_svc, id, name);
if (ret < 0) {
ldout(cct, 0) << "ERROR: failed to init period " << current_period << dendl;
return ret;
auto pool = rgw_pool{get_pool(cct)};
auto oid = get_control_oid();
bufferlist bl;
- return rgw_put_system_obj(store, pool, oid, bl, exclusive,
- nullptr, real_time(), nullptr);
+ auto obj_ctx = sysobj_svc->init_obj_ctx();
+ auto sysobj = sysobj_svc->get_obj(obj_ctx, rgw_raw_obj{pool, oid});
+ return sysobj.wop()
+ .set_exclusive(exclusive)
+ .write(bl);
}
int RGWRealm::delete_control()
{
auto pool = rgw_pool{get_pool(cct)};
auto obj = rgw_raw_obj{pool, get_control_oid()};
- return store->delete_system_obj(obj);
+ auto obj_ctx = sysobj_svc->init_obj_ctx();
+ auto sysobj = sysobj_svc->get_obj(obj_ctx, obj);
+ return sysobj.wop().remove();
}
rgw_pool RGWRealm::get_pool(CephContext *cct)
return {pool_name};
}
-int RGWPeriodConfig::read(RGWRados *store, const std::string& realm_id)
+int RGWPeriodConfig::read(RGWSI_SysObj *sysobj_svc, const std::string& realm_id)
{
- RGWSysObjectCtx obj_ctx = sysobj_svc->get_obj_ctx();
-
- const auto& pool = get_pool(store->ctx());
+ const auto& pool = get_pool(sysobj_svc->ctx());
const auto& oid = get_oid(realm_id);
bufferlist bl;
- int ret = rgw_get_system_obj(store, obj_ctx, pool, oid, bl, nullptr, nullptr);
+ auto obj_ctx = sysobj_svc->init_obj_ctx();
+ auto sysobj = sysobj_svc->get_obj(obj_ctx, rgw_raw_obj{pool, oid});
+ int ret = sysobj.rop().read(&bl);
if (ret < 0) {
return ret;
}
return 0;
}
-int RGWPeriodConfig::write(RGWRados *store, const std::string& realm_id)
+int RGWPeriodConfig::write(RGWSI_SysObj *sysobj_svc, const std::string& realm_id)
{
- const auto& pool = get_pool(store->ctx());
+ const auto& pool = get_pool(sysobj_svc->ctx());
const auto& oid = get_oid(realm_id);
bufferlist bl;
using ceph::encode;
encode(*this, bl);
- return rgw_put_system_obj(store, pool, oid, bl,
- false, nullptr, real_time(), nullptr);
+ auto obj_ctx = sysobj_svc->init_obj_ctx();
+ auto sysobj = sysobj_svc->get_obj(obj_ctx, rgw_raw_obj{pool, oid});
+ return sysobj.wop()
+ .set_exclusive(false)
+ .write(bl);
}
-int RGWPeriod::init(CephContext *_cct, RGWRados *_store, const string& period_realm_id,
+int RGWPeriod::init(CephContext *_cct, RGWSI_SysObj *_sysobj_svc, const string& period_realm_id,
const string& period_realm_name, bool setup_obj)
{
cct = _cct;
- store = _store;
+ sysobj_svc = _sysobj_svc;
+
realm_id = period_realm_id;
realm_name = period_realm_name;
if (!setup_obj)
return 0;
- return init(_cct, _store, setup_obj);
+ return init(_cct, _sysobj_svc, setup_obj);
}
-int RGWPeriod::init(CephContext *_cct, RGWRados *_store, bool setup_obj)
+int RGWPeriod::init(CephContext *_cct, RGWSI_SysObj *_sysobj_svc, bool setup_obj)
{
cct = _cct;
- store = _store;
+ sysobj_svc = _sysobj_svc;
if (!setup_obj)
return 0;
if (id.empty()) {
RGWRealm realm(realm_id, realm_name);
- int ret = realm.init(cct, store);
+ int ret = realm.init(cct, sysobj_svc);
if (ret < 0) {
ldout(cct, 0) << "RGWPeriod::init failed to init realm " << realm_name << " id " << realm_id << " : " <<
cpp_strerror(-ret) << dendl;
return -ENOENT;
}
-bool RGWRados::get_redirect_zone_endpoint(string *endpoint)
-{
- if (zone_public_config.redirect_zone.empty()) {
- return false;
- }
-
- auto iter = zone_conn_map.find(zone_public_config.redirect_zone);
- if (iter == zone_conn_map.end()) {
- ldout(cct, 0) << "ERROR: cannot find entry for redirect zone: " << zone_public_config.redirect_zone << dendl;
- return false;
- }
-
- RGWRESTConn *conn = iter->second;
-
- int ret = conn->get_url(*endpoint);
- if (ret < 0) {
- ldout(cct, 0) << "ERROR: redirect zone, conn->get_endpoint() returned ret=" << ret << dendl;
- return false;
- }
-
- return true;
-}
-
const string& RGWPeriod::get_latest_epoch_oid()
{
if (cct->_conf->rgw_period_latest_epoch_info_oid.empty()) {
rgw_pool pool(get_pool(cct));
bufferlist bl;
- RGWSysObjectCtx obj_ctx = sysobj_svc->get_obj_ctx();
-
- int ret = rgw_get_system_obj(store, obj_ctx, pool, oid, bl, objv, nullptr);
+ auto obj_ctx = sysobj_svc->init_obj_ctx();
+ auto sysobj = sysobj_svc->get_obj(obj_ctx, rgw_raw_obj{pool, oid});
+ int ret = sysobj.rop().read(&bl);
if (ret < 0) {
ldout(cct, 1) << "error read_lastest_epoch " << pool << ":" << oid << dendl;
return ret;
using ceph::encode;
encode(info, bl);
- return rgw_put_system_obj(store, pool, oid, bl,
- exclusive, objv, real_time(), nullptr);
+ auto obj_ctx = sysobj_svc->init_obj_ctx();
+ auto sysobj = sysobj_svc->get_obj(obj_ctx, rgw_raw_obj(pool, oid));
+ return sysobj.wop()
+ .set_exclusive(exclusive)
+ .write(bl);
}
int RGWPeriod::update_latest_epoch(epoch_t epoch)
for (epoch_t e = 1; e <= epoch; e++) {
RGWPeriod p{get_id(), e};
rgw_raw_obj oid{pool, p.get_period_oid()};
- int ret = store->delete_system_obj(oid);
+ auto obj_ctx = sysobj_svc->init_obj_ctx();
+ auto sysobj = sysobj_svc->get_obj(obj_ctx, oid);
+ int ret = sysobj.wop().remove();
if (ret < 0) {
ldout(cct, 0) << "WARNING: failed to delete period object " << oid
<< ": " << cpp_strerror(-ret) << dendl;
// delete the .latest_epoch object
rgw_raw_obj oid{pool, get_period_oid_prefix() + get_latest_epoch_oid()};
- int ret = store->delete_system_obj(oid);
+ auto obj_ctx = sysobj_svc->init_obj_ctx();
+ auto sysobj = sysobj_svc->get_obj(obj_ctx, oid);
+ int ret = sysobj.wop().remove();
if (ret < 0) {
ldout(cct, 0) << "WARNING: failed to delete period object " << oid
<< ": " << cpp_strerror(-ret) << dendl;
bufferlist bl;
- RGWSysObjectCtx obj_ctx = sysobj_svc->get_obj_ctx();
-
-
- int ret = rgw_get_system_obj(store, obj_ctx, pool, get_period_oid(), bl, NULL, NULL);
+ auto obj_ctx = sysobj_svc->init_obj_ctx();
+ auto sysobj = sysobj_svc->get_obj(obj_ctx, rgw_raw_obj{pool, get_period_oid()});
+ int ret = sysobj.rop().read(&bl);
if (ret < 0) {
ldout(cct, 0) << "failed reading obj info from " << pool << ":" << get_period_oid() << ": " << cpp_strerror(-ret) << dendl;
return ret;
using ceph::encode;
encode(*this, bl);
- return rgw_put_system_obj(store, pool, oid, bl,
- exclusive, NULL, real_time(), NULL);
+ auto obj_ctx = sysobj_svc->init_obj_ctx();
+ auto sysobj = sysobj_svc->get_obj(obj_ctx, rgw_raw_obj(pool, oid));
+ return sysobj.wop()
+ .set_exclusive(exclusive)
+ .write(bl);
}
rgw_pool RGWPeriod::get_pool(CephContext *cct)
int RGWPeriod::update()
{
+ auto zone_svc = sysobj_svc->get_zone_svc();
ldout(cct, 20) << __func__ << " realm " << realm_id << " period " << get_id() << dendl;
list<string> zonegroups;
- int ret = store->list_zonegroups(zonegroups);
+ int ret = zone_svc->list_zonegroups(zonegroups);
if (ret < 0) {
ldout(cct, 0) << "ERROR: failed to list zonegroups: " << cpp_strerror(-ret) << dendl;
return ret;
for (auto& iter : zonegroups) {
RGWZoneGroup zg(string(), iter);
- ret = zg.init(cct, store);
+ ret = zg.init(cct, sysobj_svc);
if (ret < 0) {
ldout(cct, 0) << "WARNING: zg.init() failed: " << cpp_strerror(-ret) << dendl;
continue;
}
}
- ret = period_config.read(store, realm_id);
+ ret = period_config.read(sysobj_svc, realm_id);
if (ret < 0 && ret != -ENOENT) {
ldout(cct, 0) << "ERROR: failed to read period config: "
<< cpp_strerror(ret) << dendl;
{
for (auto& iter : period_map.zonegroups) {
RGWZoneGroup& zg = iter.second;
- zg.reinit_instance(cct, store);
+ zg.reinit_instance(cct, sysobj_svc);
int r = zg.write(false);
if (r < 0) {
ldout(cct, 0) << "ERROR: failed to store zonegroup info for zonegroup=" << iter.first << ": " << cpp_strerror(-r) << dendl;
}
}
- int r = period_config.write(store, realm_id);
+ int r = period_config.write(sysobj_svc, realm_id);
if (r < 0) {
ldout(cct, 0) << "ERROR: failed to store period config: "
<< cpp_strerror(-r) << dendl;
int RGWPeriod::commit(RGWRealm& realm, const RGWPeriod& current_period,
std::ostream& error_stream, bool force_if_stale)
{
+ auto zone_svc = sysobj_svc->get_zone_svc();
ldout(cct, 20) << __func__ << " realm " << realm.get_id() << " period " << current_period.get_id() << dendl;
// gateway must be in the master zone to commit
- if (master_zone != store->get_zone_params().get_id()) {
+ if (master_zone != zone_svc->get_zone_params().get_id()) {
error_stream << "Cannot commit period on zone "
- << store->get_zone_params().get_id() << ", it must be sent to "
+ << zone_svc->get_zone_params().get_id() << ", it must be sent to "
"the period's master zone " << master_zone << '.' << std::endl;
return -EINVAL;
}
int get_zones_pool_set(CephContext* cct,
- RGWRados* store,
+ RGWSI_SysObj* sysobj_svc,
const list<string>& zones,
const string& my_zone_id,
set<rgw_pool>& pool_names)
{
for(auto const& iter : zones) {
RGWZoneParams zone(iter);
- int r = zone.init(cct, store);
+ int r = zone.init(cct, sysobj_svc);
if (r < 0) {
ldout(cct, 0) << "Error: init zone " << iter << ":" << cpp_strerror(-r) << dendl;
return r;
{
list<string> zones;
- int r = store->list_zones(zones);
+ int r = zone_svc->list_zones(zones);
if (r < 0) {
ldout(cct, 10) << "WARNING: store->list_zones() returned r=" << r << dendl;
}
set<rgw_pool> pools;
- r = get_zones_pool_set(cct, store, zones, id, pools);
+ r = get_zones_pool_set(cct, zone_svc, zones, id, pools);
if (r < 0) {
ldout(cct, 0) << "Error: get_zones_pool_names" << r << dendl;
return r;
{
/* check for old pools config */
rgw_raw_obj obj(domain_root, avail_pools);
- int r = store->raw_obj_stat(obj, NULL, NULL, NULL, NULL, NULL, NULL);
+ auto obj_ctx = sysobj_svc->init_obj_ctx();
+ auto sysobj = sysobj_svc->get_obj(obj_ctx, obj);
+ int r = sysobj.rop().stat();
if (r < 0) {
- ldout(store->ctx(), 10) << "couldn't find old data placement pools config, setting up new ones for the zone" << dendl;
+ ldout(cct, 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;
return cct->_conf->rgw_zone;
}
-int RGWZoneParams::init(CephContext *cct, RGWRados *store, bool setup_obj, bool old_format)
+int RGWZoneParams::init(CephContext *cct, RGWSI_SysObj *sysobj_svc, bool setup_obj, bool old_format)
{
if (name.empty()) {
name = cct->_conf->rgw_zone;
}
- return RGWSystemMetaObj::init(cct, store, setup_obj, old_format);
+ return RGWSystemMetaObj::init(cct, sysobj_svc, setup_obj, old_format);
}
int RGWZoneParams::read_default_id(string& default_id, bool old_format)
if (realm_id.empty()) {
/* try using default realm */
RGWRealm realm;
- int ret = realm.init(cct, store);
+ int ret = realm.init(cct, sysobj_svc);
//no default realm exist
if (ret < 0) {
return read_id(default_zone_name, default_id);
if (realm_id.empty()) {
/* try using default realm */
RGWRealm realm;
- int ret = realm.init(cct, store);
+ int ret = realm.init(cct, sysobj_svc);
if (ret < 0) {
ldout(cct, 10) << "could not read realm id: " << cpp_strerror(-ret) << dendl;
return -EINVAL;
return i->second;
}
-int RGWZoneGroupMap::read(CephContext *cct, RGWRados *store)
+int RGWZoneGroupMap::read(CephContext *cct, RGWSI_SysObj *sysobj_svc)
{
RGWPeriod period;
- int ret = period.init(cct, store);
+ int ret = period.init(cct, sysobj_svc);
if (ret < 0) {
cerr << "failed to read current period info: " << cpp_strerror(ret);
return ret;
#ifndef CEPH_RGW_ZONE_H
#define CEPH_RGW_ZONE_H
+#include "rgw_common.h"
+
+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;
+
+}
+
+class JSONObj;
+
struct RGWNameToId {
- string obj_id;
+ std::string obj_id;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
WRITE_CLASS_ENCODER(RGWNameToId)
struct RGWDefaultSystemMetaObjInfo {
- string default_id;
+ std::string default_id;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
WRITE_CLASS_ENCODER(RGWDefaultSystemMetaObjInfo)
class RGWSI_SysObj;
+class RGWSI_Zone;
class RGWSystemMetaObj {
protected:
- string id;
- string name;
+ std::string id;
+ std::string name;
CephContext *cct{nullptr};
RGWSI_SysObj *sysobj_svc{nullptr};
+ RGWSI_Zone *zone_svc{nullptr};
int store_name(bool exclusive);
int store_info(bool exclusive);
- int read_info(const string& obj_id, bool old_format = false);
- int read_id(const string& obj_name, string& obj_id);
+ int read_info(const std::string& obj_id, bool old_format = false);
+ int read_id(const std::string& obj_name, std::string& obj_id);
int read_default(RGWDefaultSystemMetaObjInfo& default_info,
- const string& oid);
+ const std::string& oid);
/* read and use default id */
int use_default(bool old_format = false);
public:
RGWSystemMetaObj() {}
- RGWSystemMetaObj(const string& _name): name(_name) {}
- RGWSystemMetaObj(const string& _id, const string& _name) : id(_id), name(_name) {}
- RGWSystemMetaObj(CephContext *_cct, RGWSI_SysObj *_sysobj_svc): cct(_cct), sysobj_svc(_sysobj_svc){}
- RGWSystemMetaObj(const string& _name, CephContext *_cct, RGWSI_SysObj *_sysobj_svc): name(_name), cct(_cct), sysobj_svc(_sysobj_svc){}
+ RGWSystemMetaObj(const std::string& _name): name(_name) {}
+ RGWSystemMetaObj(const std::string& _id, const std::string& _name) : id(_id), name(_name) {}
+ RGWSystemMetaObj(CephContext *_cct, RGWSI_SysObj *_sysobj_svc) {
+ reinit_instance(_cct, _sysobj_svc);
+ }
+ RGWSystemMetaObj(const std::string& _name, CephContext *_cct, RGWSI_SysObj *_sysobj_svc): name(_name) {
+ reinit_instance(_cct, _sysobj_svc);
+ }
- const string& get_name() const { return name; }
- const string& get_id() const { return id; }
+ const std::string& get_name() const { return name; }
+ const std::string& get_id() const { return id; }
- void set_name(const string& _name) { name = _name;}
- void set_id(const string& _id) { id = _id;}
+ void set_name(const std::string& _name) { name = _name;}
+ void set_id(const std::string& _id) { id = _id;}
void clear_id() { id.clear(); }
virtual ~RGWSystemMetaObj() {}
DECODE_FINISH(bl);
}
- void reinit_instance(CephContext *_cct, RGWSI_SysObj *_sysobj_svc) {
- cct = _cct;
- sysobj_svc = _sysobj_svc;
- }
+ void reinit_instance(CephContext *_cct, RGWSI_SysObj *_sysobj_svc);
int init(CephContext *_cct, RGWSI_SysObj *_sysobj_svc, bool setup_obj = true, bool old_format = false);
- virtual int read_default_id(string& default_id, bool old_format = false);
+ virtual int read_default_id(std::string& default_id, bool old_format = false);
virtual int set_as_default(bool exclusive = false);
int delete_default();
virtual int create(bool exclusive = true);
int delete_obj(bool old_format = false);
- int rename(const string& new_name);
+ int rename(const std::string& new_name);
int update() { return store_info(false);}
int update_name() { return store_name(false);}
int read();
int write(bool exclusive);
virtual rgw_pool get_pool(CephContext *cct) = 0;
- virtual const string get_default_oid(bool old_format = false) = 0;
- virtual const string& get_names_oid_prefix() = 0;
- virtual const string& get_info_oid_prefix(bool old_format = false) = 0;
- virtual const string& get_predefined_name(CephContext *cct) = 0;
+ virtual const std::string get_default_oid(bool old_format = false) = 0;
+ virtual const std::string& get_names_oid_prefix() = 0;
+ virtual const std::string& get_info_oid_prefix(bool old_format = false) = 0;
+ virtual const std::string& get_predefined_name(CephContext *cct) = 0;
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
void decode(bufferlist::const_iterator& bl) {
DECODE_START(6, bl);
- string index_pool_str;
- string data_pool_str;
+ 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);
data_pool = rgw_pool(data_pool_str);
if (struct_v >= 4) {
- string data_extra_pool_str;
+ std::string data_extra_pool_str;
decode(data_extra_pool_str, bl);
data_extra_pool = rgw_pool(data_extra_pool_str);
}
RGWAccessKey system_key;
- map<string, RGWZonePlacementInfo> placement_pools;
+ map<std::string, RGWZonePlacementInfo> placement_pools;
- string realm_id;
+ std::string realm_id;
JSONFormattable tier_config;
RGWZoneParams() : RGWSystemMetaObj() {}
- explicit RGWZoneParams(const string& name) : RGWSystemMetaObj(name){}
- RGWZoneParams(const string& id, const string& name) : RGWSystemMetaObj(id, name) {}
- RGWZoneParams(const string& id, const string& name, const string& _realm_id)
+ explicit RGWZoneParams(const std::string& name) : RGWSystemMetaObj(name){}
+ RGWZoneParams(const std::string& id, const std::string& name) : RGWSystemMetaObj(id, name) {}
+ RGWZoneParams(const std::string& id, const std::string& name, const std::string& _realm_id)
: RGWSystemMetaObj(id, name), realm_id(_realm_id) {}
rgw_pool get_pool(CephContext *cct) override;
- const string get_default_oid(bool old_format = false) override;
- const string& get_names_oid_prefix() override;
- const string& get_info_oid_prefix(bool old_format = false) override;
- const string& get_predefined_name(CephContext *cct) override;
+ const std::string get_default_oid(bool old_format = false) override;
+ const std::string& get_names_oid_prefix() override;
+ const std::string& get_info_oid_prefix(bool old_format = false) override;
+ const std::string& get_predefined_name(CephContext *cct) override;
int init(CephContext *_cct, RGWSI_SysObj *_sysobj_svc, bool setup_obj = true,
bool old_format = false);
using RGWSystemMetaObj::init;
- int read_default_id(string& default_id, bool old_format = false) override;
+ int read_default_id(std::string& default_id, bool old_format = false) override;
int set_as_default(bool exclusive = false) override;
int create_default(bool old_format = false);
int create(bool exclusive = true) override;
int fix_pool_names();
- const string& get_compression_type(const string& placement_rule) const;
+ const std::string& get_compression_type(const std::string& placement_rule) const;
void encode(bufferlist& bl) const override {
ENCODE_START(12, 1, bl);
encode(metadata_heap, bl);
encode(realm_id, bl);
encode(lc_pool, bl);
- map<string, string, ltstr_nocase> old_tier_config;
+ map<std::string, std::string, ltstr_nocase> old_tier_config;
encode(old_tier_config, bl);
encode(roles_pool, bl);
encode(reshard_pool, bl);
} else {
lc_pool = log_pool.name + ":lc";
}
- map<string, string, ltstr_nocase> old_tier_config;
+ map<std::string, std::string, ltstr_nocase> old_tier_config;
if (struct_v >= 8) {
decode(old_tier_config, bl);
}
void decode_json(JSONObj *obj);
static void generate_test_instances(list<RGWZoneParams*>& o);
- bool get_placement(const string& placement_id, RGWZonePlacementInfo *placement) const {
+ bool get_placement(const std::string& placement_id, RGWZonePlacementInfo *placement) const {
auto iter = placement_pools.find(placement_id);
if (iter == placement_pools.end()) {
return false;
/*
* return data pool of the head object
*/
- bool get_head_data_pool(const string& placement_id, const rgw_obj& obj, rgw_pool *pool) const {
+ bool get_head_data_pool(const std::string& placement_id, const rgw_obj& obj, rgw_pool *pool) const {
const rgw_data_placement_target& explicit_placement = obj.bucket.explicit_placement;
if (!explicit_placement.data_pool.empty()) {
if (!obj.in_extra_data) {
WRITE_CLASS_ENCODER(RGWZoneParams)
struct RGWZone {
- string id;
- string name;
- list<string> endpoints;
+ std::string id;
+ std::string name;
+ list<std::string> endpoints;
bool log_meta;
bool log_data;
bool read_only;
- string tier_type;
+ std::string tier_type;
- string redirect_zone;
+ std::string redirect_zone;
/**
* Represents the number of shards for the bucket index object, a value of zero
uint32_t bucket_index_max_shards;
bool sync_from_all;
- set<string> sync_from; /* list of zones to sync from */
+ set<std::string> sync_from; /* list of zones to sync from */
RGWZone() : log_meta(false), log_data(false), read_only(false), bucket_index_max_shards(0),
sync_from_all(true) {}
bool is_read_only() { return read_only; }
- bool syncs_from(const string& zone_id) const {
+ bool syncs_from(const std::string& zone_id) const {
return (sync_from_all || sync_from.find(zone_id) != sync_from.end());
}
};
WRITE_CLASS_ENCODER(RGWZone)
struct RGWDefaultZoneGroupInfo {
- string default_zonegroup;
+ std::string default_zonegroup;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
WRITE_CLASS_ENCODER(RGWDefaultZoneGroupInfo)
struct RGWZoneGroupPlacementTarget {
- string name;
- set<string> tags;
+ std::string name;
+ set<std::string> tags;
- bool user_permitted(list<string>& user_tags) const {
+ bool user_permitted(list<std::string>& user_tags) const {
if (tags.empty()) {
return true;
}
struct RGWZoneGroup : public RGWSystemMetaObj {
- string api_name;
- list<string> endpoints;
+ std::string api_name;
+ list<std::string> endpoints;
bool is_master = false;
- string master_zone;
- map<string, RGWZone> zones;
+ std::string master_zone;
+ map<std::string, RGWZone> zones;
- map<string, RGWZoneGroupPlacementTarget> placement_targets;
- string default_placement;
+ map<std::string, RGWZoneGroupPlacementTarget> placement_targets;
+ std::string default_placement;
- list<string> hostnames;
- list<string> hostnames_s3website;
- // TODO: Maybe convert hostnames to a map<string,list<string>> for
+ list<std::string> hostnames;
+ list<std::string> hostnames_s3website;
+ // TODO: Maybe convert hostnames to a map<std::string,list<std::string>> for
// endpoint_type->hostnames
/*
20:05 < _robbat21irssi> maybe I do someting like: if (hostname_map.empty()) { populate all map keys from hostnames; };
20:05 < _robbat21irssi> but that's a later compatability migration planning bit
20:06 < yehudasa> more like if (!hostnames.empty()) {
-20:06 < yehudasa> for (list<string>::iterator iter = hostnames.begin(); iter != hostnames.end(); ++iter) {
+20:06 < yehudasa> for (list<std::string>::iterator iter = hostnames.begin(); iter != hostnames.end(); ++iter) {
20:06 < yehudasa> hostname_map["s3"].append(iter->second);
20:07 < yehudasa> hostname_map["s3website"].append(iter->second);
20:07 < yehudasa> s/append/push_back/g
20:08 < yehudasa> yeah, probably
20:08 < _robbat21irssi> s3, s3website, swift, swith_auth, swift_website
*/
- map<string, list<string> > api_hostname_map;
- map<string, list<string> > api_endpoints_map;
+ map<std::string, list<std::string> > api_hostname_map;
+ map<std::string, list<std::string> > api_endpoints_map;
- string realm_id;
+ std::string realm_id;
RGWZoneGroup(): is_master(false){}
RGWZoneGroup(const std::string &id, const std::string &name):RGWSystemMetaObj(id, name) {}
explicit RGWZoneGroup(const std::string &_name):RGWSystemMetaObj(_name) {}
RGWZoneGroup(const std::string &_name, bool _is_master, CephContext *cct, RGWSI_SysObj* sysobj_svc,
- const string& _realm_id, const list<string>& _endpoints)
+ const std::string& _realm_id, const list<std::string>& _endpoints)
: RGWSystemMetaObj(_name, cct , sysobj_svc), endpoints(_endpoints), is_master(_is_master),
realm_id(_realm_id) {}
DECODE_FINISH(bl);
}
- int read_default_id(string& default_id, bool old_format = false) override;
+ int read_default_id(std::string& default_id, bool old_format = false) override;
int set_as_default(bool exclusive = false) override;
int create_default(bool old_format = false);
- int equals(const string& other_zonegroup) const;
+ int equals(const std::string& other_zonegroup) const;
int add_zone(const RGWZoneParams& zone_params, bool *is_master, bool *read_only,
- const list<string>& endpoints, const string *ptier_type,
- bool *psync_from_all, list<string>& sync_from, list<string>& sync_from_rm,
- string *predirect_zone);
+ const list<std::string>& endpoints, const std::string *ptier_type,
+ bool *psync_from_all, list<std::string>& sync_from, list<std::string>& sync_from_rm,
+ std::string *predirect_zone);
int remove_zone(const std::string& zone_id);
int rename_zone(const RGWZoneParams& zone_params);
rgw_pool get_pool(CephContext *cct) override;
- const string get_default_oid(bool old_region_format = false) override;
- const string& get_info_oid_prefix(bool old_region_format = false) override;
- const string& get_names_oid_prefix() override;
- const string& get_predefined_name(CephContext *cct) override;
+ const std::string get_default_oid(bool old_region_format = false) override;
+ const std::string& get_info_oid_prefix(bool old_region_format = false) override;
+ const std::string& get_names_oid_prefix() override;
+ const std::string& get_predefined_name(CephContext *cct) override;
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
struct RGWPeriodMap
{
- string id;
- map<string, RGWZoneGroup> zonegroups;
- map<string, RGWZoneGroup> zonegroups_by_api;
- map<string, uint32_t> short_zone_ids;
+ std::string id;
+ map<std::string, RGWZoneGroup> zonegroups;
+ map<std::string, RGWZoneGroup> zonegroups_by_api;
+ map<std::string, uint32_t> short_zone_ids;
- string master_zonegroup;
+ std::string master_zonegroup;
void encode(bufferlist& bl) const;
void decode(bufferlist::const_iterator& bl);
master_zonegroup.clear();
}
- uint32_t get_zone_short_id(const string& zone_id) const;
+ uint32_t get_zone_short_id(const std::string& zone_id) const;
};
WRITE_CLASS_ENCODER(RGWPeriodMap)
/* for backward comaptability */
struct RGWRegionMap {
- map<string, RGWZoneGroup> regions;
+ map<std::string, RGWZoneGroup> regions;
- string master_region;
+ std::string master_region;
RGWQuotaInfo bucket_quota;
RGWQuotaInfo user_quota;
struct RGWZoneGroupMap {
- map<string, RGWZoneGroup> zonegroups;
- map<string, RGWZoneGroup> zonegroups_by_api;
+ map<std::string, RGWZoneGroup> zonegroups;
+ map<std::string, RGWZoneGroup> zonegroups_by_api;
- string master_zonegroup;
+ std::string master_zonegroup;
RGWQuotaInfo bucket_quota;
RGWQuotaInfo user_quota;
class RGWRealm : public RGWSystemMetaObj
{
- string current_period;
+ std::string current_period;
epoch_t epoch{0}; //< realm epoch, incremented for each new period
int create_control(bool exclusive);
int delete_control();
public:
RGWRealm() {}
- RGWRealm(const string& _id, const string& _name = "") : RGWSystemMetaObj(_id, _name) {}
+ RGWRealm(const std::string& _id, const std::string& _name = "") : RGWSystemMetaObj(_id, _name) {}
RGWRealm(CephContext *_cct, RGWSI_SysObj *_sysobj_svc): RGWSystemMetaObj(_cct, _sysobj_svc) {}
- RGWRealm(const string& _name, CephContext *_cct, RGWSI_SysObj *_sysobj_svc): RGWSystemMetaObj(_name, _cct, _sysobj_svc){}
+ RGWRealm(const std::string& _name, CephContext *_cct, RGWSI_SysObj *_sysobj_svc): RGWSystemMetaObj(_name, _cct, _sysobj_svc){}
void encode(bufferlist& bl) const override {
ENCODE_START(1, 1, bl);
int create(bool exclusive = true) override;
int delete_obj();
rgw_pool get_pool(CephContext *cct) override;
- const string get_default_oid(bool old_format = false) override;
- const string& get_names_oid_prefix() override;
- const string& get_info_oid_prefix(bool old_format = false) override;
- const string& get_predefined_name(CephContext *cct) override;
+ const std::string get_default_oid(bool old_format = false) override;
+ const std::string& get_names_oid_prefix() override;
+ const std::string& get_info_oid_prefix(bool old_format = false) override;
+ const std::string& get_predefined_name(CephContext *cct) override;
using RGWSystemMetaObj::read_id; // expose as public for radosgw-admin
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
- const string& get_current_period() const {
+ const std::string& get_current_period() const {
return current_period;
}
int set_current_period(RGWPeriod& period);
}
epoch_t get_epoch() const { return epoch; }
- string get_control_oid();
+ std::string get_control_oid();
/// send a notify on the realm control object
int notify_zone(bufferlist& bl);
/// notify the zone of a new period
class RGWPeriod
{
- string id;
+ std::string id;
epoch_t epoch{0};
- string predecessor_uuid;
+ std::string predecessor_uuid;
std::vector<std::string> sync_status;
RGWPeriodMap period_map;
RGWPeriodConfig period_config;
- string master_zonegroup;
- string master_zone;
+ std::string master_zonegroup;
+ std::string master_zone;
- string realm_id;
- string realm_name;
+ std::string realm_id;
+ std::string realm_name;
epoch_t realm_epoch{1}; //< realm epoch when period was made current
CephContext *cct{nullptr};
int use_latest_epoch();
int use_current_period();
- const string get_period_oid();
- const string get_period_oid_prefix();
+ const std::string get_period_oid();
+ const std::string get_period_oid_prefix();
// gather the metadata sync status for each shard; only for use on master zone
int update_sync_status(const RGWPeriod ¤t_period,
public:
RGWPeriod() {}
- RGWPeriod(const string& period_id, epoch_t _epoch = 0)
+ RGWPeriod(const std::string& period_id, epoch_t _epoch = 0)
: id(period_id), epoch(_epoch) {}
- const string& get_id() const { return id; }
+ const std::string& get_id() const { return id; }
epoch_t get_epoch() const { return epoch; }
epoch_t get_realm_epoch() const { return realm_epoch; }
- const string& get_predecessor() const { return predecessor_uuid; }
- const string& get_master_zone() const { return master_zone; }
- const string& get_master_zonegroup() const { return master_zonegroup; }
- const string& get_realm() const { return realm_id; }
+ const std::string& get_predecessor() const { return predecessor_uuid; }
+ const std::string& get_master_zone() const { return master_zone; }
+ const std::string& get_master_zonegroup() const { return master_zonegroup; }
+ const std::string& get_realm() const { return realm_id; }
const RGWPeriodMap& get_map() const { return period_map; }
RGWPeriodConfig& get_config() { return period_config; }
const RGWPeriodConfig& get_config() const { return period_config; }
const std::vector<std::string>& get_sync_status() const { return sync_status; }
rgw_pool get_pool(CephContext *cct);
- const string& get_latest_epoch_oid();
- const string& get_info_oid_prefix();
+ const std::string& get_latest_epoch_oid();
+ const std::string& get_info_oid_prefix();
void set_user_quota(RGWQuotaInfo& user_quota) {
period_config.user_quota = user_quota;
period_config.bucket_quota = bucket_quota;
}
- void set_id(const string& id) {
+ void set_id(const std::string& id) {
this->id = id;
period_map.id = id;
}
void set_epoch(epoch_t epoch) { this->epoch = epoch; }
void set_realm_epoch(epoch_t epoch) { realm_epoch = epoch; }
- void set_predecessor(const string& predecessor)
+ void set_predecessor(const std::string& predecessor)
{
predecessor_uuid = predecessor;
}
- void set_realm_id(const string& _realm_id) {
+ void set_realm_id(const std::string& _realm_id) {
realm_id = _realm_id;
}
int reflect();
int get_zonegroup(RGWZoneGroup& zonegroup,
- const string& zonegroup_id);
+ const std::string& zonegroup_id);
bool is_single_zonegroup() const
{
// update latest_epoch if the given epoch is higher, else return -EEXIST
int update_latest_epoch(epoch_t epoch);
- int init(CephContext *_cct, RGWSI_SysObj *_sysobj_svc, const string &period_realm_id, const string &period_realm_name = "",
+ int init(CephContext *_cct, RGWSI_SysObj *_sysobj_svc, const std::string &period_realm_id, const std::string &period_realm_name = "",
bool setup_obj = true);
int init(CephContext *_cct, RGWSI_SysObj *_sysobj_svc, bool setup_obj = true);
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
- static string get_staging_id(const string& realm_id) {
+ static std::string get_staging_id(const std::string& realm_id) {
return realm_id + ":staging";
}
};
return svc->omap_del(obj, key);
}
+
+RGWSI_Zone *RGWSI_SysObj::get_zone_svc()
+{
+ return core_svc->get_zone_svc();
+}
return Pool(core_svc.get(), pool);
}
+ RGWSI_Zone *get_zone_svc();
};
using RGWSysObj = RGWSI_SysObj::Obj;
public:
RGWSI_SysObj_Core(RGWService *svc, CephContext *cct): RGWServiceInstance(svc, cct) {}
+ RGWSI_Zone *get_zone_svc() {
+ return zone_svc.get();
+ }
};
#endif
#define dout_subsys ceph_subsys_rgw
-static string zone_names_oid_prefix = "zone_names.";
-static string region_info_oid_prefix = "region_info.";
-static string realm_names_oid_prefix = "realms_names.";
-static string default_region_info_oid = "default.region";
-static string region_map_oid = "region_map";
-const string default_zonegroup_name = "default";
-const string default_zone_name = "default";
-static string zonegroup_names_oid_prefix = "zonegroups_names.";
-static string RGW_DEFAULT_ZONE_ROOT_POOL = "rgw.root";
-static string RGW_DEFAULT_ZONEGROUP_ROOT_POOL = "rgw.root";
-static string RGW_DEFAULT_REALM_ROOT_POOL = "rgw.root";
-static string RGW_DEFAULT_PERIOD_ROOT_POOL = "rgw.root";
-static string avail_pools = ".pools.avail";
-static string default_storage_pool_suffix = "rgw.buckets.data";
+using namespace rgw_zone_defaults;
int RGWS_Zone::create_instance(const string& conf, RGWServiceInstanceRef *instance)
{
return names.size();
}
+bool RGWSI_Zone::get_redirect_zone_endpoint(string *endpoint)
+{
+ if (zone_public_config->redirect_zone.empty()) {
+ return false;
+ }
+
+ auto iter = zone_conn_map.find(zone_public_config->redirect_zone);
+ if (iter == zone_conn_map.end()) {
+ ldout(cct, 0) << "ERROR: cannot find entry for redirect zone: " << zone_public_config->redirect_zone << dendl;
+ return false;
+ }
+
+ RGWRESTConn *conn = iter->second;
+
+ int ret = conn->get_url(*endpoint);
+ if (ret < 0) {
+ ldout(cct, 0) << "ERROR: redirect zone, conn->get_endpoint() returned ret=" << ret << dendl;
+ return false;
+ }
+
+ return true;
+}
+
projects / ceph.git / commitdiff