#include "include/types.h"
-class Formatter;
-
struct cls_refcount_get_op {
string tag;
bool implicit_ref;
#include <fstream>
#include <include/types.h>
+#include <boost/algorithm/string.hpp>
+
using namespace json_spirit;
#define dout_subsys ceph_subsys_rgw
+
+static JSONFormattable default_formattable;
+
+
JSONObjIter::JSONObjIter()
{
}
encode_json(name, s, f);
}
+
+
+/* JSONFormattable */
+
+const JSONFormattable& JSONFormattable::operator[](const string& name) const
+{
+ auto i = obj.find(name);
+ if (i == obj.end()) {
+ return default_formattable;
+ }
+ return i->second;
+}
+
+bool JSONFormattable::find(const string& name, string *val) const
+{
+ auto i = obj.find(name);
+ if (i == obj.end()) {
+ return false;
+ }
+ *val = i->second;
+ return true;
+}
+
+string JSONFormattable::get(const string& name, const string& def_val) const
+{
+ string s;
+ if (find(name, &s)) {
+ return s;
+ }
+
+ return def_val;
+}
+
+int JSONFormattable::get_int(const string& name, int def_val) const
+{
+ string s;
+ if (find(name, &s)) {
+ return atoi(s.c_str());
+ }
+
+ return def_val;
+}
+
+bool JSONFormattable::get_bool(const string& name, bool def_val) const
+{
+ string s;
+ if (find(name, &s)) {
+ return (boost::iequals(s, "true") ||
+ boost::iequals(s, "on") ||
+ boost::iequals(s, "yes") ||
+ boost::iequals(s, "1"));
+ }
+
+ return def_val;
+}
+
+void encode_json(const char *name, const JSONFormattable& v, Formatter *f)
+{
+ switch (v.type) {
+ case JSONFormattable::FMT_STRING:
+ encode_json(name, v.str, f);
+ break;
+ case JSONFormattable::FMT_ARRAY:
+ encode_json(name, v.arr, f);
+ break;
+ case JSONFormattable::FMT_OBJ:
+ f->open_object_section(name);
+ for (auto iter : v.obj) {
+ encode_json(iter.first.c_str(), iter.second, f);
+ }
+ f->close_section();
+ break;
+ case JSONFormattable::FMT_NONE:
+ break;
+ }
+}
+
encode_json_map<K, V>(name, index_name, NULL, value_name, NULL, NULL, m, f);
}
+struct JSONFormattable {
+ enum Type {
+ FMT_NONE,
+ FMT_STRING,
+ FMT_ARRAY,
+ FMT_OBJ,
+ } type{FMT_NONE};
+ string str;
+ vector<JSONFormattable> arr;
+ map<string, JSONFormattable> obj;
+
+ void decode_json(JSONObj *jo) {
+ if (jo->is_array()) {
+ type = JSONFormattable::FMT_ARRAY;
+ decode_json_obj(arr, jo);
+ } else if (jo->is_object()) {
+ type = JSONFormattable::FMT_OBJ;
+ auto iter = jo->find_first();
+ while (!iter.end()) {
+ JSONObj *field = *iter;
+ decode_json_obj(obj[field->get_name()], field);
+ }
+ } else {
+ type = JSONFormattable::FMT_STRING;
+ decode_json_obj(str, jo);
+ }
+ }
+
+ void encode(bufferlist& bl) const {
+ ENCODE_START(1, 1, bl);
+ encode((uint8_t)type, bl);
+ encode(str, bl);
+ encode(arr, bl);
+ encode(obj, bl);
+ ENCODE_FINISH(bl);
+ }
+
+ void decode(bufferlist::iterator& bl) {
+ DECODE_START(1, bl);
+ uint8_t t;
+ decode(t, bl);
+ type = (Type)t;
+ decode(str, bl);
+ decode(arr, bl);
+ decode(obj, bl);
+ DECODE_FINISH(bl);
+ }
+ const string& val() const {
+ return str;
+ }
+
+ const vector<JSONFormattable>& array() const {
+ return arr;
+ }
+
+ const JSONFormattable& operator[](const string& name) const;
+
+ operator string() const {
+ return val();
+ }
+
+ bool find(const string& name, string *val) const;
+
+ string get(const string& name, const string& def_val) const;
+ int get_int(const string& name, int def_val) const;
+ bool get_bool(const string& name, bool def_val) const;
+};
+WRITE_CLASS_ENCODER(JSONFormattable)
+
+void encode_json(const char *name, const JSONFormattable& v, Formatter *f);
+
#endif
return -ENOENT;
}
-struct Formattable {
- enum Type {
- FMT_NONE,
- FMT_STRING,
- FMT_ARRAY,
- FMT_OBJ,
- } type{FMT_NONE};
- string str;
- vector<Formattable> arr;
- map<string, Formattable> obj;
-
- void decode_json(JSONObj *jo) {
- if (jo->is_array()) {
- type = Formattable::FMT_ARRAY;
- decode_json_obj(arr, jo);
- } else if (jo->is_object()) {
- type = Formattable::FMT_OBJ;
- auto iter = jo->find_first();
- while (!iter.end()) {
- JSONObj *field;
- decode_json_obj(obj[field->get_name()], field);
- }
- } else {
- type = Formattable::FMT_STRING;
- decode_json_obj(str, jo);
- }
- }
-
- const string& val() const {
- return str;
- }
-
- const vector<Formattable>& array() const {
- return arr;
- }
-
- const Formattable& operator[](const string& name) const;
-};
-
-static Formattable default_formattable;
-
-const Formattable& Formattable::operator[](const string& name) const {
- auto i = obj.find(name);
- if (i == obj.end()) {
- return default_formattable;
- }
- return i->second;
-}
-
-void encode_json(const char *name, const Formattable& v, Formatter *f)
-{
- switch (v.type) {
- case Formattable::FMT_STRING:
- encode_json(name, v.str, f);
- break;
- case Formattable::FMT_ARRAY:
- encode_json(name, v.arr, f);
- break;
- case Formattable::FMT_OBJ:
- f->open_object_section(name);
- for (auto iter : v.obj) {
- encode_json(iter.first.c_str(), iter.second, f);
- }
- f->close_section();
- break;
- case Formattable::FMT_NONE:
- break;
- }
-}
-
-
#ifdef BUILDING_FOR_EMBEDDED
extern "C" int cephd_rgw_admin(int argc, const char **argv)
#else
}
};
-int RGWDefaultSyncModule::create_instance(CephContext *cct, map<string, string, ltstr_nocase>& config, RGWSyncModuleInstanceRef *instance)
+int RGWDefaultSyncModule::create_instance(CephContext *cct, const JSONFormattable& config, RGWSyncModuleInstanceRef *instance)
{
instance->reset(new RGWDefaultSyncModuleInstance());
return 0;
public:
RGWDefaultSyncModule() {}
bool supports_data_export() override { return true; }
- int create_instance(CephContext *cct, map<string, string, ltstr_nocase>& config, RGWSyncModuleInstanceRef *instance) override;
+ int create_instance(CephContext *cct, const JSONFormattable& config, RGWSyncModuleInstanceRef *instance) override;
};
// DataLogTrimCR factory function
#include "common/RWLock.h"
#include "common/ceph_time.h"
#include "common/lru_map.h"
+#include "common/ceph_json.h"
#include "rgw_common.h"
#include "cls/rgw/cls_rgw_types.h"
#include "cls/version/cls_version_types.h"
string realm_id;
- map<string, string, ltstr_nocase> tier_config;
+ JSONFormattable tier_config;
RGWZoneParams() : RGWSystemMetaObj() {}
RGWZoneParams(const string& name) : RGWSystemMetaObj(name){}
typedef std::shared_ptr<RGWSyncModuleInstance> RGWSyncModuleInstanceRef;
+class JSONFormattable;
+
class RGWSyncModule {
public:
virtual ~RGWSyncModule() {}
virtual bool supports_data_export() = 0;
- virtual int create_instance(CephContext *cct, map<string, string, ltstr_nocase>& config, RGWSyncModuleInstanceRef *instance) = 0;
+ virtual int create_instance(CephContext *cct, const JSONFormattable& config, RGWSyncModuleInstanceRef *instance) = 0;
};
typedef std::shared_ptr<RGWSyncModule> RGWSyncModuleRef;
return module.get()->supports_data_export();
}
- int create_instance(CephContext *cct, const string& name, map<string, string, ltstr_nocase>& config, RGWSyncModuleInstanceRef *instance) {
+ int create_instance(CephContext *cct, const string& name, const JSONFormattable& config, RGWSyncModuleInstanceRef *instance) {
RGWSyncModuleRef module;
if (!get_module(name, &module)) {
return -ENOENT;
}
};
-static int conf_to_uint64(CephContext *cct, const map<string, string, ltstr_nocase>& config, const string& key, uint64_t *pval)
+static int conf_to_uint64(CephContext *cct, const JSONFormattable& config, const string& key, uint64_t *pval)
{
- auto i = config.find(key);
- if (i != config.end()) {
+ string sval;
+ if (config.find(key, &sval)) {
string err;
- uint64_t val = strict_strtoll(i->second.c_str(), 10, &err);
+ uint64_t val = strict_strtoll(sval.c_str(), 10, &err);
if (!err.empty()) {
- ldout(cct, 0) << "ERROR: could not parse configurable value for cloud sync module: " << i->first << ": " << i->second << dendl;
+ ldout(cct, 0) << "ERROR: could not parse configurable value for cloud sync module: " << key << ": " << sval << dendl;
return -EINVAL;
}
*pval = val;
return 0;
}
-int RGWAWSSyncModule::create_instance(CephContext *cct, map<string, string, ltstr_nocase>& config, RGWSyncModuleInstanceRef *instance){
+int RGWAWSSyncModule::create_instance(CephContext *cct, const JSONFormattable& config, RGWSyncModuleInstanceRef *instance){
AWSSyncConfig conf;
- auto i = config.find("s3_endpoint");
- if (i != config.end())
- conf.s3_endpoint = i->second;
- string access_key;
- string secret;
+ conf.s3_endpoint = config["s3_endpoint"];
- i = config.find("access_key");
- if (i != config.end())
- access_key = i->second;
-
- i = config.find("secret");
- if (i != config.end())
- secret = i->second;
+ string access_key = config["access_key"];
+ string secret = config["secret"];
conf.key = RGWAccessKey(access_key, secret);
public:
RGWAWSSyncModule() {}
bool supports_data_export() override { return false;}
- int create_instance(CephContext *cct, map<string, string, ltstr_nocase>& config, RGWSyncModuleInstanceRef *instance) override;
+ int create_instance(CephContext *cct, const JSONFormattable& config, RGWSyncModuleInstanceRef *instance) override;
};
#endif /* RGW_SYNC_MODULE_AWS_H */
#define ES_NUM_SHARDS_DEFAULT 16
#define ES_NUM_REPLICAS_DEFAULT 1
+
struct ElasticConfig {
uint64_t sync_instance{0};
string id;
uint32_t num_shards{0};
uint32_t num_replicas{0};
- void init(CephContext *cct, const map<string, string, ltstr_nocase>& config) {
- string elastic_endpoint = rgw_conf_get(config, "endpoint", "");
+ void init(CephContext *cct, const JSONFormattable& config) {
+ string elastic_endpoint = config.get("endpoint", "");
id = string("elastic:") + elastic_endpoint;
conn.reset(new RGWRESTConn(cct, nullptr, id, { elastic_endpoint }));
- explicit_custom_meta = rgw_conf_get_bool(config, "explicit_custom_meta", true);
- index_buckets.init(rgw_conf_get(config, "index_buckets_list", ""), true); /* approve all buckets by default */
- allow_owners.init(rgw_conf_get(config, "approved_owners_list", ""), true); /* approve all bucket owners by default */
- override_index_path = rgw_conf_get(config, "override_index_path", "");
- num_shards = rgw_conf_get_int(config, "num_shards", ES_NUM_SHARDS_DEFAULT);
+ explicit_custom_meta = config.get_bool("explicit_custom_meta", true);
+ index_buckets.init(config.get("index_buckets_list", ""), true); /* approve all buckets by default */
+ allow_owners.init(config.get("approved_owners_list", ""), true); /* approve all bucket owners by default */
+ override_index_path = config.get("override_index_path", "");
+ num_shards = config.get_int("num_shards", ES_NUM_SHARDS_DEFAULT);
if (num_shards < ES_NUM_SHARDS_MIN) {
num_shards = ES_NUM_SHARDS_MIN;
}
- num_replicas = rgw_conf_get_int(config, "num_replicas", ES_NUM_REPLICAS_DEFAULT);
+ num_replicas = config.get_int("num_replicas", ES_NUM_REPLICAS_DEFAULT);
}
void init_instance(RGWRealm& realm, uint64_t instance_id) {
class RGWElasticDataSyncModule : public RGWDataSyncModule {
ElasticConfigRef conf;
public:
- RGWElasticDataSyncModule(CephContext *cct, const map<string, string, ltstr_nocase>& config) : conf(std::make_shared<ElasticConfig>()) {
+ RGWElasticDataSyncModule(CephContext *cct, const JSONFormattable& config) : conf(std::make_shared<ElasticConfig>()) {
conf->init(cct, config);
}
~RGWElasticDataSyncModule() override {}
}
};
-RGWElasticSyncModuleInstance::RGWElasticSyncModuleInstance(CephContext *cct, const map<string, string, ltstr_nocase>& config)
+RGWElasticSyncModuleInstance::RGWElasticSyncModuleInstance(CephContext *cct, const JSONFormattable& config)
{
data_handler = std::unique_ptr<RGWElasticDataSyncModule>(new RGWElasticDataSyncModule(cct, config));
}
return new RGWRESTMgr_MDSearch_S3();
}
-int RGWElasticSyncModule::create_instance(CephContext *cct, map<string, string, ltstr_nocase>& config, RGWSyncModuleInstanceRef *instance) {
- string endpoint;
- auto i = config.find("endpoint");
- if (i != config.end()) {
- endpoint = i->second;
- }
+int RGWElasticSyncModule::create_instance(CephContext *cct, const JSONFormattable& config, RGWSyncModuleInstanceRef *instance) {
+ string endpoint = config["endpoint"];
instance->reset(new RGWElasticSyncModuleInstance(cct, config));
return 0;
}
bool supports_data_export() override {
return false;
}
- int create_instance(CephContext *cct, map<string, string, ltstr_nocase>& config, RGWSyncModuleInstanceRef *instance) override;
+ int create_instance(CephContext *cct, const JSONFormattable& config, RGWSyncModuleInstanceRef *instance) override;
};
class RGWElasticDataSyncModule;
class RGWElasticSyncModuleInstance : public RGWSyncModuleInstance {
std::unique_ptr<RGWElasticDataSyncModule> data_handler;
public:
- RGWElasticSyncModuleInstance(CephContext *cct, const std::map<std::string, std::string, ltstr_nocase>& config);
+ RGWElasticSyncModuleInstance(CephContext *cct, const JSONFormattable& config);
RGWDataSyncModule *get_data_handler() override;
RGWRESTMgr *get_rest_filter(int dialect, RGWRESTMgr *orig) override;
RGWRESTConn *get_rest_conn();
}
};
-int RGWLogSyncModule::create_instance(CephContext *cct, map<string, string, ltstr_nocase>& config, RGWSyncModuleInstanceRef *instance) {
- string prefix;
- auto i = config.find("prefix");
- if (i != config.end()) {
- prefix = i->second;
- }
+int RGWLogSyncModule::create_instance(CephContext *cct, const JSONFormattable& config, RGWSyncModuleInstanceRef *instance) {
+ string prefix = config["prefix"];
instance->reset(new RGWLogSyncModuleInstance(prefix));
return 0;
}
bool supports_data_export() override {
return false;
}
- int create_instance(CephContext *cct, map<string, string, ltstr_nocase>& config, RGWSyncModuleInstanceRef *instance) override;
+ int create_instance(CephContext *cct, const JSONFormattable& config, RGWSyncModuleInstanceRef *instance) override;
};
#endif
projects / ceph-ci.git / commitdiff