#include "rgw_rest_s3.h"
#include "rgw_rest_swift.h"
#include "rgw_rest_admin.h"
+#include "rgw_rest_info.h"
#include "rgw_rest_usage.h"
#include "rgw_rest_user.h"
#include "rgw_rest_bucket.h"
#include "rgw_rest_config.h"
#include "rgw_rest_realm.h"
#include "rgw_rest_sts.h"
+#include "rgw_rest_ratelimit.h"
#include "rgw_swift_auth.h"
#include "rgw_log.h"
#include "rgw_tools.h"
#ifdef WITH_RADOSGW_KAFKA_ENDPOINT
#include "rgw_kafka.h"
#endif
-#if defined(WITH_RADOSGW_BEAST_FRONTEND)
#include "rgw_asio_frontend.h"
-#endif /* WITH_RADOSGW_BEAST_FRONTEND */
#include "rgw_dmclock_scheduler_ctx.h"
#ifdef WITH_RADOSGW_LUA_PACKAGES
#include "rgw_lua.h"
#endif
+#ifdef WITH_RADOSGW_DBSTORE
+#include "rgw_sal_dbstore.h"
+#endif
#include "services/svc_zone.h"
#define dout_subsys ceph_subsys_rgw
+using namespace std;
+
namespace {
TracepointProvider::Traits rgw_op_tracepoint_traits("librgw_op_tp.so",
"rgw_op_tracing");
static void handle_sigterm(int signum)
{
dout(1) << __func__ << dendl;
-#if defined(WITH_RADOSGW_FCGI_FRONTEND)
- FCGX_ShutdownPending();
-#endif
// 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
return mgr;
}
-static RGWRESTMgr *rest_filter(RGWRados *store, int dialect, RGWRESTMgr *orig)
+static RGWRESTMgr *rest_filter(rgw::sal::Store* store, int dialect, RGWRESTMgr *orig)
{
RGWSyncModuleInstanceRef sync_module = store->get_sync_module();
if (sync_module) {
map<string,string> defaults = {
{ "debug_rgw", "1/5" },
{ "keyring", "$rgw_data/keyring" },
- { "objecter_inflight_ops", "24576" }
+ { "objecter_inflight_ops", "24576" },
+ // require a secure mon connection by default
+ { "ms_mon_client_mode", "secure" },
+ { "auth_client_required", "cephx" }
};
- vector<const char*> args;
- argv_to_vec(argc, argv, args);
+ auto args = argv_to_vec(argc, argv);
if (args.empty()) {
cerr << argv[0] << ": -h or --help for usage" << std::endl;
exit(1);
multimap<string, RGWFrontendConfig *> fe_map;
list<RGWFrontendConfig *> configs;
if (frontends.empty()) {
- frontends.push_back("civetweb");
+ frontends.push_back("beast");
}
for (list<string>::iterator iter = frontends.begin(); iter != frontends.end(); ++iter) {
string& f = *iter;
- if (f.find("civetweb") != string::npos || f.find("beast") != string::npos) {
+ if (f.find("beast") != string::npos) {
if (f.find("port") != string::npos) {
// check for the most common ws problems
if ((f.find("port=") == string::npos) ||
TracepointProvider::initialize<rgw_rados_tracepoint_traits>(g_ceph_context);
TracepointProvider::initialize<rgw_op_tracepoint_traits>(g_ceph_context);
- int r = rgw_tools_init(g_ceph_context);
+ const DoutPrefix dp(cct.get(), dout_subsys, "rgw main: ");
+ int r = rgw_tools_init(&dp, g_ceph_context);
if (r < 0) {
derr << "ERROR: unable to initialize rgw tools" << dendl;
return -r;
rgw_http_client_init(g_ceph_context);
rgw_kmip_client_init(*new RGWKMIPManagerImpl(g_ceph_context));
-#if defined(WITH_RADOSGW_FCGI_FRONTEND)
- FCGX_Init();
+ lsubdout(cct, rgw, 1) << "rgw_d3n: rgw_d3n_l1_local_datacache_enabled=" << cct->_conf->rgw_d3n_l1_local_datacache_enabled << dendl;
+ if (cct->_conf->rgw_d3n_l1_local_datacache_enabled) {
+ 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;
+ }
+ bool rgw_d3n_datacache_enabled = cct->_conf->rgw_d3n_l1_local_datacache_enabled;
+ if (rgw_d3n_datacache_enabled && (cct->_conf->rgw_max_chunk_size != cct->_conf->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;
+ rgw_d3n_datacache_enabled = false;
+ }
+ if (rgw_d3n_datacache_enabled && !cct->_conf->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;
+ rgw_d3n_datacache_enabled = false;
+ }
+ lsubdout(cct, rgw, 1) << "D3N datacache enabled: " << rgw_d3n_datacache_enabled << dendl;
+
+ std::string rgw_store = (!rgw_d3n_datacache_enabled) ? "rados" : "d3n";
+
+ const auto& config_store = g_conf().get_val<std::string>("rgw_backend_store");
+#ifdef WITH_RADOSGW_DBSTORE
+ if (config_store == "dbstore") {
+ rgw_store = "dbstore";
+ }
#endif
- const DoutPrefix dp(cct.get(), dout_subsys, "rgw main: ");
- rgw::sal::RGWRadosStore *store =
- RGWStoreManager::get_storage(&dp, g_ceph_context,
+ rgw::sal::Store* store =
+ StoreManager::get_storage(&dp, g_ceph_context,
+ rgw_store,
g_conf()->rgw_enable_gc_threads,
g_conf()->rgw_enable_lc_threads,
g_conf()->rgw_enable_quota_threads,
return -r;
}
- rgw_rest_init(g_ceph_context, store->svc()->zone->get_zonegroup());
+ rgw_rest_init(g_ceph_context, store->get_zone()->get_zonegroup());
mutex.lock();
init_timer.cancel_all_events();
init_timer.shutdown();
mutex.unlock();
- rgw_log_usage_init(g_ceph_context, store->getRados());
+ rgw_log_usage_init(g_ceph_context, store);
RGWREST rest;
const bool swift_at_root = g_conf()->rgw_swift_url_prefix == "/";
if (apis_map.count("s3") > 0 || s3website_enabled) {
if (! swift_at_root) {
- rest.register_default_mgr(set_logging(rest_filter(store->getRados(), RGW_REST_S3,
+ rest.register_default_mgr(set_logging(rest_filter(store, RGW_REST_S3,
new RGWRESTMgr_S3(s3website_enabled, sts_enabled, iam_enabled, pubsub_enabled))));
} else {
derr << "Cannot have the S3 or S3 Website enabled together with "
store->set_luarocks_path(luarocks_path+"/"+g_conf()->name.to_str());
}
#ifdef WITH_RADOSGW_LUA_PACKAGES
- rgw::lua::packages_t failed_packages;
- std::string output;
- r = rgw::lua::install_packages(&dp, store, null_yield, failed_packages, output);
- if (r < 0) {
- dout(1) << "ERROR: failed to install lua packages from allowlist" << dendl;
- }
- if (!output.empty()) {
- dout(10) << "INFO: lua packages installation output: \n" << output << dendl;
- }
- for (const auto& p : failed_packages) {
- dout(5) << "WARNING: failed to install lua package: " << p << " from allowlist" << dendl;
+ rgw::sal::RadosStore *rados = dynamic_cast<rgw::sal::RadosStore*>(store);
+ if (rados) { /* Supported for only RadosStore */
+ rgw::lua::packages_t failed_packages;
+ std::string output;
+ r = rgw::lua::install_packages(&dp, rados, null_yield, failed_packages, output);
+ if (r < 0) {
+ dout(1) << "ERROR: failed to install lua packages from allowlist" << dendl;
+ }
+ if (!output.empty()) {
+ dout(10) << "INFO: lua packages installation output: \n" << output << dendl;
+ }
+ for (const auto& p : failed_packages) {
+ dout(5) << "WARNING: failed to install lua package: " << p << " from allowlist" << dendl;
+ }
}
#endif
if (! swift_at_root) {
rest.register_resource(g_conf()->rgw_swift_url_prefix,
- set_logging(rest_filter(store->getRados(), RGW_REST_SWIFT,
+ set_logging(rest_filter(store, RGW_REST_SWIFT,
swift_resource)));
} else {
- if (store->svc()->zone->get_zonegroup().zones.size() > 1) {
+ if (store->get_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;
if (apis_map.count("admin") > 0) {
RGWRESTMgr_Admin *admin_resource = new RGWRESTMgr_Admin;
+ admin_resource->register_resource("info", new RGWRESTMgr_Info);
admin_resource->register_resource("usage", new RGWRESTMgr_Usage);
admin_resource->register_resource("user", new RGWRESTMgr_User);
+ /* XXX dang part of this is RADOS specific */
admin_resource->register_resource("bucket", new RGWRESTMgr_Bucket);
/*Registering resource for /admin/metadata */
admin_resource->register_resource("metadata", new RGWRESTMgr_Metadata);
+ /* XXX dang ifdef these RADOS ? */
admin_resource->register_resource("log", new RGWRESTMgr_Log);
admin_resource->register_resource("config", new RGWRESTMgr_Config);
admin_resource->register_resource("realm", new RGWRESTMgr_Realm);
+ admin_resource->register_resource("ratelimit", new RGWRESTMgr_Ratelimit);
rest.register_resource(g_conf()->rgw_admin_entry, admin_resource);
}
rgw::auth::ImplicitTenants implicit_tenant_context{g_conf()};
g_conf().add_observer(&implicit_tenant_context);
auto auth_registry = \
- rgw::auth::StrategyRegistry::create(g_ceph_context, implicit_tenant_context, store->getRados()->pctl);
+ rgw::auth::StrategyRegistry::create(g_ceph_context, implicit_tenant_context, store);
/* Header custom behavior */
rest.register_x_headers(g_conf()->rgw_log_http_headers);
rgw::dmclock::SchedulerCtx sched_ctx{cct.get()};
OpsLogManifold *olog = new OpsLogManifold();
+ ActiveRateLimiter ratelimiting{cct.get()};
+ ratelimiting.start();
+
if (!g_conf()->rgw_ops_log_socket_path.empty()) {
OpsLogSocket* olog_socket = new OpsLogSocket(g_ceph_context, g_conf()->rgw_ops_log_data_backlog);
olog_socket->init(g_conf()->rgw_ops_log_socket_path);
ops_log_file->start();
olog->add_sink(ops_log_file);
}
- olog->add_sink(new OpsLogRados(store->getRados()));
+ olog->add_sink(new OpsLogRados(store));
r = signal_fd_init();
if (r < 0) {
RGWFrontend *fe = NULL;
- if (framework == "civetweb" || framework == "mongoose") {
- lderr(cct.get()) << "IMPORTANT: the civetweb frontend is now deprecated "
- "and will be removed in a future release" << dendl;
- framework = "civetweb";
- std::string uri_prefix;
- config->get_val("prefix", "", &uri_prefix);
-
- RGWProcessEnv env = { store, &rest, olog, 0, uri_prefix, auth_registry };
- //TODO: move all of scheduler initializations to frontends?
-
- fe = new RGWCivetWebFrontend(env, config, sched_ctx);
- }
- else if (framework == "loadgen") {
+ if (framework == "loadgen") {
int port;
config->get_val("port", 80, &port);
std::string uri_prefix;
config->get_val("prefix", "", &uri_prefix);
- RGWProcessEnv env = { store, &rest, olog, port, uri_prefix, auth_registry };
+ RGWProcessEnv env = { store, &rest, olog, port, uri_prefix, auth_registry, &ratelimiting };
fe = new RGWLoadGenFrontend(env, config);
}
-#if defined(WITH_RADOSGW_BEAST_FRONTEND)
else if (framework == "beast") {
int port;
config->get_val("port", 80, &port);
std::string uri_prefix;
config->get_val("prefix", "", &uri_prefix);
- RGWProcessEnv env{ store, &rest, olog, port, uri_prefix, auth_registry };
+ RGWProcessEnv env{ store, &rest, olog, port, uri_prefix, auth_registry, &ratelimiting };
fe = new RGWAsioFrontend(env, config, sched_ctx);
}
-#endif /* WITH_RADOSGW_BEAST_FRONTEND */
-#if defined(WITH_RADOSGW_FCGI_FRONTEND)
- else if (framework == "fastcgi" || framework == "fcgi") {
- framework = "fastcgi";
- std::string uri_prefix;
- config->get_val("prefix", "", &uri_prefix);
- RGWProcessEnv fcgi_pe = { store, &rest, olog, 0, uri_prefix, auth_registry };
-
- fe = new RGWFCGXFrontend(fcgi_pe, config);
- }
-#endif /* WITH_RADOSGW_FCGI_FRONTEND */
service_map_meta["frontend_type#" + stringify(fe_count)] = framework;
service_map_meta["frontend_config#" + stringify(fe_count)] = config->get_config();
fes.push_back(fe);
}
- r = store->getRados()->register_to_service_map("rgw", service_map_meta);
+ r = store->register_to_service_map(&dp, "rgw", service_map_meta);
if (r < 0) {
derr << "ERROR: failed to register to service map: " << cpp_strerror(-r) << dendl;
auto reloader = std::make_unique<RGWRealmReloader>(store,
service_map_meta, &pauser);
- RGWRealmWatcher realm_watcher(&dp, g_ceph_context, store->svc()->zone->get_realm());
+ RGWRealmWatcher realm_watcher(&dp, g_ceph_context, store->get_zone()->get_realm());
realm_watcher.add_watcher(RGWRealmNotify::Reload, *reloader);
realm_watcher.add_watcher(RGWRealmNotify::ZonesNeedPeriod, pusher);
rgw_log_usage_finalize();
delete olog;
- RGWStoreManager::close_storage(store);
+ StoreManager::close_storage(store);
rgw::auth::s3::LDAPEngine::shutdown();
rgw_tools_cleanup();
rgw_shutdown_resolver();
projects / ceph.git / blobdiff