assert("ErasureCode::decode_chunks not implemented" == 0);
}
-int ErasureCode::parse(const map<std::string,std::string> ¶meters,
+int ErasureCode::parse(const ErasureCodeProfile &profile,
ostream *ss)
{
- return to_mapping(parameters, ss);
+ return to_mapping(profile, ss);
}
const vector<int> &ErasureCode::get_chunk_mapping() const {
return chunk_mapping;
}
-int ErasureCode::to_mapping(const map<std::string,std::string> ¶meters,
+int ErasureCode::to_mapping(const ErasureCodeProfile &profile,
ostream *ss)
{
- if (parameters.find("mapping") != parameters.end()) {
- std::string mapping = parameters.find("mapping")->second;
+ if (profile.find("mapping") != profile.end()) {
+ std::string mapping = profile.find("mapping")->second;
int position = 0;
vector<int> coding_chunk_mapping;
for(std::string::iterator it = mapping.begin(); it != mapping.end(); ++it) {
}
int ErasureCode::to_int(const std::string &name,
- const map<std::string,std::string> ¶meters,
+ ErasureCodeProfile &profile,
int *value,
int default_value,
ostream *ss)
{
- if (parameters.find(name) == parameters.end() ||
- parameters.find(name)->second.size() == 0) {
+ if (profile.find(name) == profile.end() ||
+ profile.find(name)->second.size() == 0) {
*value = default_value;
return 0;
}
- std::string p = parameters.find(name)->second;
+ std::string p = profile.find(name)->second;
std::string err;
int r = strict_strtol(p.c_str(), 10, &err);
if (!err.empty()) {
}
int ErasureCode::to_bool(const std::string &name,
- const map<std::string,std::string> ¶meters,
+ ErasureCodeProfile &profile,
bool *value,
bool default_value,
ostream *ss)
{
- if (parameters.find(name) == parameters.end() ||
- parameters.find(name)->second.size() == 0) {
+ if (profile.find(name) == profile.end() ||
+ profile.find(name)->second.size() == 0) {
*value = default_value;
return 0;
}
- const std::string p = parameters.find(name)->second;
+ const std::string p = profile.find(name)->second;
*value = (p == "yes") || (p == "true");
return 0;
}
const map<int, bufferlist> &chunks,
map<int, bufferlist> *decoded);
- virtual int parse(const map<std::string,std::string> ¶meters,
+ virtual int parse(const ErasureCodeProfile &profile,
ostream *ss);
virtual const vector<int> &get_chunk_mapping() const;
- int to_mapping(const map<std::string,std::string> ¶meters,
+ int to_mapping(const ErasureCodeProfile &profile,
ostream *ss);
static int to_int(const std::string &name,
- const map<std::string,std::string> ¶meters,
+ ErasureCodeProfile &profile,
int *value,
int default_value,
ostream *ss);
static int to_bool(const std::string &name,
- const map<std::string,std::string> ¶meters,
+ ErasureCodeProfile &profile,
bool *value,
bool default_value,
ostream *ss);
namespace ceph {
+ typedef map<std::string,std::string> ErasureCodeProfile;
class ErasureCodeInterface {
public:
virtual ~ErasureCodeInterface() {}
}
int ErasureCodePluginRegistry::factory(const std::string &plugin_name,
- const map<std::string,std::string> ¶meters,
+ ErasureCodeProfile &profile,
ErasureCodeInterfaceRef *erasure_code,
ostream &ss)
{
plugin = get(plugin_name);
if (plugin == 0) {
loading = true;
- assert(parameters.count("directory") != 0);
- int r = load(plugin_name, parameters.find("directory")->second, &plugin, ss);
+ assert(profile.count("directory") != 0);
+ int r = load(plugin_name, profile.find("directory")->second, &plugin, ss);
loading = false;
if (r != 0)
return r;
}
}
- return plugin->factory(parameters, erasure_code);
+ return plugin->factory(profile, erasure_code);
}
static const char *an_older_version() {
library(0) {}
virtual ~ErasureCodePlugin() {}
- virtual int factory(const map<std::string,std::string> ¶meters,
+ virtual int factory(ErasureCodeProfile &profile,
ErasureCodeInterfaceRef *erasure_code) = 0;
};
}
int factory(const std::string &plugin,
- const map<std::string,std::string> ¶meters,
+ ErasureCodeProfile &profile,
ErasureCodeInterfaceRef *erasure_code,
ostream &ss);
// -----------------------------------------------------------------------------
void
-ErasureCodeIsa::init(const map<string, string> ¶meters)
+ErasureCodeIsa::init(ErasureCodeProfile &profile)
{
dout(10) << "technique=" << technique << dendl;
map<string, string>::const_iterator parameter;
- parameter = parameters.find("ruleset-root");
- if (parameter != parameters.end())
+ parameter = profile.find("ruleset-root");
+ if (parameter != profile.end())
ruleset_root = parameter->second;
- parameter = parameters.find("ruleset-failure-domain");
- if (parameter != parameters.end())
+ parameter = profile.find("ruleset-failure-domain");
+ if (parameter != profile.end())
ruleset_failure_domain = parameter->second;
ostringstream ss;
- if (parse(parameters, &ss))
+ if (parse(profile, &ss))
derr << ss.str() << dendl;
prepare();
}
// -----------------------------------------------------------------------------
-int ErasureCodeIsaDefault::parse(const map<std::string,
- std::string> ¶meters,
+int ErasureCodeIsaDefault::parse(ErasureCodeProfile &profile,
ostream *ss)
{
- int err = ErasureCode::parse(parameters, ss);
- err |= to_int("k", parameters, &k, DEFAULT_K, ss);
- err |= to_int("m", parameters, &m, DEFAULT_M, ss);
+ int err = ErasureCode::parse(profile, ss);
+ err |= to_int("k", profile, &k, DEFAULT_K, ss);
+ err |= to_int("m", profile, &m, DEFAULT_M, ss);
if (matrixtype == kVandermonde) {
// these are verified safe values evaluated using the
const map<int, bufferlist> &chunks,
map<int, bufferlist> *decoded);
- void init(const map<std::string, std::string> ¶meters);
+ void init(ErasureCodeProfile &profile);
virtual void isa_encode(char **data,
char **coding,
virtual unsigned get_alignment() const = 0;
- virtual int parse(const map<std::string,
- std::string> ¶meters,
+ virtual int parse(ErasureCodeProfile &profile,
ostream *ss) = 0;
virtual void prepare() = 0;
virtual unsigned get_alignment() const;
- virtual int parse(const map<std::string,
- std::string> ¶meters,
+ virtual int parse(ErasureCodeProfile &profile,
ostream *ss);
virtual void prepare();
public:
ErasureCodeIsaTableCache tcache;
- virtual int factory(const map<std::string, std::string> ¶meters,
+ virtual int factory(ErasureCodeProfile &profile,
ErasureCodeInterfaceRef *erasure_code)
{
ErasureCodeIsa *interface;
std::string t = "reed_sol_van";
- if (parameters.find("technique") != parameters.end())
- t = parameters.find("technique")->second;
+ if (profile.find("technique") != profile.end())
+ t = profile.find("technique")->second;
if ((t == "reed_sol_van")) {
interface = new ErasureCodeIsaDefault(tcache,
ErasureCodeIsaDefault::kVandermonde);
}
}
- interface->init(parameters);
+ interface->init(profile);
*erasure_code = ErasureCodeInterfaceRef(interface);
return 0;
}
}
}
-void ErasureCodeJerasure::init(const map<string,string> ¶meters)
+void ErasureCodeJerasure::init(ErasureCodeProfile& profile)
{
dout(10) << "technique=" << technique << dendl;
map<string,string>::const_iterator parameter;
- parameter = parameters.find("ruleset-root");
- if (parameter != parameters.end())
+ parameter = profile.find("ruleset-root");
+ if (parameter != profile.end())
ruleset_root = parameter->second;
- parameter = parameters.find("ruleset-failure-domain");
- if (parameter != parameters.end())
+ parameter = profile.find("ruleset-failure-domain");
+ if (parameter != profile.end())
ruleset_failure_domain = parameter->second;
ostringstream ss;
- if (parse(parameters, &ss))
+ if (parse(profile, &ss))
derr << ss.str() << dendl;
prepare();
}
-int ErasureCodeJerasure::parse(const map<std::string,std::string> ¶meters,
+int ErasureCodeJerasure::parse(ErasureCodeProfile &profile,
ostream *ss)
{
- int err = ErasureCode::parse(parameters, ss);
- err |= to_int("k", parameters, &k, DEFAULT_K, ss);
- err |= to_int("m", parameters, &m, DEFAULT_M, ss);
- err |= to_int("w", parameters, &w, DEFAULT_W, ss);
+ int err = ErasureCode::parse(profile, ss);
+ err |= to_int("k", profile, &k, DEFAULT_K, ss);
+ err |= to_int("m", profile, &m, DEFAULT_M, ss);
+ err |= to_int("w", profile, &w, DEFAULT_W, ss);
if (chunk_mapping.size() > 0 && (int)chunk_mapping.size() != k + m) {
- *ss << "mapping " << parameters.find("mapping")->second
+ *ss << "mapping " << profile.find("mapping")->second
<< " maps " << chunk_mapping.size() << " chunks instead of"
<< " the expected " << k + m << " and will be ignored" << std::endl;
chunk_mapping.clear();
}
}
-int ErasureCodeJerasureReedSolomonVandermonde::parse(const map<std::string,std::string> ¶meters,
- ostream *ss)
+int ErasureCodeJerasureReedSolomonVandermonde::parse(ErasureCodeProfile &profile,
+ ostream *ss)
{
- int err = ErasureCodeJerasure::parse(parameters, ss);
+ int err = 0;
+ err |= ErasureCodeJerasure::parse(profile, ss);
if (w != 8 && w != 16 && w != 32) {
*ss << "ReedSolomonVandermonde: w=" << w
<< " must be one of {8, 16, 32} : revert to DEFAULT_W " << std::endl;
w = DEFAULT_W;
err = -EINVAL;
}
- err |= to_bool("jerasure-per-chunk-alignment", parameters,
+ err |= to_bool("jerasure-per-chunk-alignment", profile,
&per_chunk_alignment, false, ss);
return err;
}
}
}
-int ErasureCodeJerasureReedSolomonRAID6::parse(const map<std::string,std::string> ¶meters,
+int ErasureCodeJerasureReedSolomonRAID6::parse(ErasureCodeProfile &profile,
ostream *ss)
{
- int err = ErasureCodeJerasure::parse(parameters, ss);
+ int err = ErasureCodeJerasure::parse(profile, ss);
m = 2;
if (w != 8 && w != 16 && w != 32) {
*ss << "ReedSolomonRAID6: w=" << w
}
}
-int ErasureCodeJerasureCauchy::parse(const map<std::string,std::string> ¶meters,
+int ErasureCodeJerasureCauchy::parse(ErasureCodeProfile &profile,
ostream *ss)
{
- int err = ErasureCodeJerasure::parse(parameters, ss);
- err |= to_int("packetsize", parameters, &packetsize, DEFAULT_PACKETSIZE, ss);
- err |= to_bool("jerasure-per-chunk-alignment", parameters,
+ int err = ErasureCodeJerasure::parse(profile, ss);
+ err |= to_int("packetsize", profile, &packetsize, DEFAULT_PACKETSIZE, ss);
+ err |= to_bool("jerasure-per-chunk-alignment", profile,
&per_chunk_alignment, false, ss);
return err;
}
packetsize = DEFAULT_PACKETSIZE;
}
-int ErasureCodeJerasureLiberation::parse(const map<std::string,std::string> ¶meters,
+int ErasureCodeJerasureLiberation::parse(ErasureCodeProfile &profile,
ostream *ss)
{
- int err = ErasureCodeJerasure::parse(parameters, ss);
- err |= to_int("packetsize", parameters, &packetsize, DEFAULT_PACKETSIZE, ss);
+ int err = ErasureCodeJerasure::parse(profile, ss);
+ err |= to_int("packetsize", profile, &packetsize, DEFAULT_PACKETSIZE, ss);
bool error = false;
if (!check_k(ss))
//
// ErasureCodeJerasureLiber8tion
//
-int ErasureCodeJerasureLiber8tion::parse(const map<std::string,std::string> ¶meters,
+int ErasureCodeJerasureLiber8tion::parse(ErasureCodeProfile &profile,
ostream *ss)
{
- int err = ErasureCodeJerasure::parse(parameters, ss);
+ int err = ErasureCodeJerasure::parse(profile, ss);
m = DEFAULT_M;
w = DEFAULT_W;
- err |= to_int("packetsize", parameters, &packetsize, DEFAULT_PACKETSIZE, ss);
+ err |= to_int("packetsize", profile, &packetsize, DEFAULT_PACKETSIZE, ss);
bool error = false;
if (!check_k(ss))
virtual ~ErasureCodeJerasure() {}
- virtual int parse(const map<std::string,std::string> ¶meters,
- ostream *ss);
+ virtual int parse(ErasureCodeProfile &profile, ostream *ss);
virtual int create_ruleset(const string &name,
CrushWrapper &crush,
const map<int, bufferlist> &chunks,
map<int, bufferlist> *decoded);
- void init(const map<std::string,std::string> ¶meters);
+ void init(ErasureCodeProfile &profile);
+
virtual void jerasure_encode(char **data,
char **coding,
int blocksize) = 0;
char **coding,
int blocksize);
virtual unsigned get_alignment() const;
- virtual int parse(const map<std::string,std::string> ¶meters,
- ostream *ss);
+ virtual int parse(ErasureCodeProfile &profile, ostream *ss);
virtual void prepare();
};
char **coding,
int blocksize);
virtual unsigned get_alignment() const;
- virtual int parse(const map<std::string,std::string> ¶meters,
- ostream *ss);
+ virtual int parse(ErasureCodeProfile &profile, ostream *ss);
virtual void prepare();
};
char **coding,
int blocksize);
virtual unsigned get_alignment() const;
- virtual int parse(const map<std::string,std::string> ¶meters,
- ostream *ss);
+ virtual int parse(ErasureCodeProfile &profile, ostream *ss);
void prepare_schedule(int *matrix);
};
virtual bool check_packetsize_set(ostream *ss) const;
virtual bool check_packetsize(ostream *ss) const;
virtual void revert_to_default(ostream *ss);
- virtual int parse(const map<std::string,std::string> ¶meters,
- ostream *ss);
+ virtual int parse(ErasureCodeProfile &profile, ostream *ss);
virtual void prepare();
};
DEFAULT_W = 8;
}
- virtual int parse(const map<std::string,std::string> ¶meters,
- ostream *ss);
+ virtual int parse(ErasureCodeProfile &profile, ostream *ss);
virtual void prepare();
};
class ErasureCodePluginJerasure : public ErasureCodePlugin {
public:
- virtual int factory(const map<std::string,std::string> ¶meters,
+ virtual int factory(ErasureCodeProfile &profile,
ErasureCodeInterfaceRef *erasure_code) {
ErasureCodeJerasure *interface;
std::string t;
- if (parameters.find("technique") != parameters.end())
- t = parameters.find("technique")->second;
+ if (profile.find("technique") != profile.end())
+ t = profile.find("technique")->second;
if (t == "reed_sol_van") {
interface = new ErasureCodeJerasureReedSolomonVandermonde();
} else if (t == "reed_sol_r6_op") {
<< dendl;
return -ENOENT;
}
- interface->init(parameters);
+ interface->init(profile);
*erasure_code = ErasureCodeInterfaceRef(interface);
return 0;
}
class ErasureCodePluginSelectJerasure : public ErasureCodePlugin {
public:
- virtual int factory(const map<string,string> ¶meters,
+ virtual int factory(ErasureCodeProfile &profile,
ErasureCodeInterfaceRef *erasure_code) {
ErasureCodePluginRegistry &instance = ErasureCodePluginRegistry::instance();
stringstream ss;
int ret;
string name = "jerasure";
- if (parameters.count("jerasure-name"))
- name = parameters.find("jerasure-name")->second;
- if (parameters.count("jerasure-variant")) {
+ if (profile.count("jerasure-name"))
+ name = profile.find("jerasure-name")->second;
+ if (profile.count("jerasure-variant")) {
dout(10) << "jerasure-variant "
- << parameters.find("jerasure-variant")->second << dendl;
- ret = instance.factory(name + "_" + parameters.find("jerasure-variant")->second,
- parameters, erasure_code, ss);
+ << profile.find("jerasure-variant")->second << dendl;
+ ret = instance.factory(name + "_" + profile.find("jerasure-variant")->second,
+ profile, erasure_code, ss);
} else {
string variant = get_variant();
dout(10) << variant << " plugin" << dendl;
- ret = instance.factory(name + "_" + variant, parameters, erasure_code, ss);
+ ret = instance.factory(name + "_" + variant, profile, erasure_code, ss);
}
if (ret)
derr << ss.str() << dendl;
return ruleset;
}
-int ErasureCodeLrc::layers_description(const map<string,string> ¶meters,
+int ErasureCodeLrc::layers_description(const ErasureCodeProfile &profile,
json_spirit::mArray *description,
ostream *ss) const
{
- if (parameters.count("layers") == 0) {
- *ss << "could not find 'layers' in " << parameters << std::endl;
+ if (profile.count("layers") == 0) {
+ *ss << "could not find 'layers' in " << profile << std::endl;
return ERROR_LRC_DESCRIPTION;
}
- string str = parameters.find("layers")->second;
+ string str = profile.find("layers")->second;
try {
json_spirit::mValue json;
json_spirit::read_or_throw(str, json);
return ERROR_LRC_ARRAY;
}
json_spirit::mArray layer_json = i->get_array();
- map<string, string> parameters;
+ ErasureCodeProfile profile;
int index = 0;
for (vector<json_spirit::mValue>::iterator j = layer_json.begin();
j != layer_json.end();
return ERROR_LRC_CONFIG_OPTIONS;
}
if (j->type() == json_spirit::str_type) {
- int err = get_json_str_map(j->get_str(), *ss, &layer.parameters);
+ int err = get_json_str_map(j->get_str(), *ss, &layer.profile);
if (err)
return err;
} else if (j->type() == json_spirit::obj_type) {
for (map<string, json_spirit::mValue>::iterator i = o.begin();
i != o.end();
++i) {
- layer.parameters[i->first] = i->second.get_str();
+ layer.profile[i->first] = i->second.get_str();
}
}
} else {
layer.chunks = layer.data;
layer.chunks.insert(layer.chunks.end(),
layer.coding.begin(), layer.coding.end());
- if (layer.parameters.find("k") == layer.parameters.end())
- layer.parameters["k"] = stringify(layer.data.size());
- if (layer.parameters.find("m") == layer.parameters.end())
- layer.parameters["m"] = stringify(layer.coding.size());
- if (layer.parameters.find("plugin") == layer.parameters.end())
- layer.parameters["plugin"] = "jerasure";
- if (layer.parameters.find("technique") == layer.parameters.end())
- layer.parameters["technique"] = "reed_sol_van";
- if (layer.parameters.find("directory") == layer.parameters.end())
- layer.parameters["directory"] = directory;
stringstream ss;
- int err = registry.factory(layer.parameters["plugin"],
- layer.parameters,
+ if (layer.profile.find("k") == layer.profile.end())
+ layer.profile["k"] = stringify(layer.data.size());
+ if (layer.profile.find("m") == layer.profile.end())
+ layer.profile["m"] = stringify(layer.coding.size());
+ if (layer.profile.find("plugin") == layer.profile.end())
+ layer.profile["plugin"] = "jerasure";
+ if (layer.profile.find("technique") == layer.profile.end())
+ layer.profile["technique"] = "reed_sol_van";
+ if (layer.profile.find("directory") == layer.profile.end())
+ layer.profile["directory"] = directory;
+ int err = registry.factory(layer.profile["plugin"],
+ layer.profile,
&layer.erasure_code,
ss);
if (err) {
return 0;
}
-int ErasureCodeLrc::parse(const map<string,string> ¶meters,
+int ErasureCodeLrc::parse(ErasureCodeProfile &profile,
ostream *ss)
{
- int r = ErasureCode::parse(parameters, ss);
+ int r = ErasureCode::parse(profile, ss);
if (r)
return r;
- if (parameters.count("directory") != 0)
- directory = parameters.find("directory")->second;
+ if (profile.count("directory") != 0)
+ directory = profile.find("directory")->second;
- return parse_ruleset(parameters, ss);
+ return parse_ruleset(profile, ss);
}
-int ErasureCodeLrc::parse_kml(map<string,string> ¶meters,
+int ErasureCodeLrc::parse_kml(ErasureCodeProfile &profile,
ostream *ss)
{
- int err = ErasureCode::parse(parameters, ss);
+ int err = ErasureCode::parse(profile, ss);
const int DEFAULT = -1;
int k, m, l;
- err |= to_int("k", parameters, &k, DEFAULT, ss);
- err |= to_int("m", parameters, &m, DEFAULT, ss);
- err |= to_int("l", parameters, &l, DEFAULT, ss);
+ err |= to_int("k", profile, &k, DEFAULT, ss);
+ err |= to_int("m", profile, &m, DEFAULT, ss);
+ err |= to_int("l", profile, &l, DEFAULT, ss);
if (k == DEFAULT && m == DEFAULT && l == DEFAULT)
return 0;
if ((k != DEFAULT || m != DEFAULT || l != DEFAULT) &&
(k == DEFAULT || m == DEFAULT || l == DEFAULT)) {
*ss << "All of k, m, l must be set or none of them in "
- << parameters << std::endl;
+ << profile << std::endl;
return ERROR_LRC_ALL_OR_NOTHING;
}
"ruleset-steps" };
for (int i = 0; i < 3; i++) {
- if (parameters.count(generated[i])) {
+ if (profile.count(generated[i])) {
*ss << "The " << generated[i] << " parameter cannot be set "
- << "when k, m, l are set in " << parameters << std::endl;
+ << "when k, m, l are set in " << profile << std::endl;
return ERROR_LRC_GENERATED;
}
}
if ((k + m) % l) {
*ss << "k + m must be a multiple of l in "
- << parameters << std::endl;
+ << profile << std::endl;
return ERROR_LRC_K_M_MODULO;
}
if (k % local_group_count) {
*ss << "k must be a multiple of (k + m) / l in "
- << parameters << std::endl;
+ << profile << std::endl;
return ERROR_LRC_K_MODULO;
}
if (m % local_group_count) {
*ss << "m must be a multiple of (k + m) / l in "
- << parameters << std::endl;
+ << profile << std::endl;
return ERROR_LRC_M_MODULO;
}
mapping += string(k / local_group_count, 'D') +
string(m / local_group_count, '_') + "_";
}
- parameters["mapping"] = mapping;
+ profile["mapping"] = mapping;
string layers = "[ ";
}
layers += "\", \"\" ],";
}
- parameters["layers"] = layers + "]";
+ profile["layers"] = layers + "]";
- map<string,string>::const_iterator parameter;
+ ErasureCodeProfile::const_iterator parameter;
string ruleset_locality;
- parameter = parameters.find("ruleset-locality");
- if (parameter != parameters.end())
+ parameter = profile.find("ruleset-locality");
+ if (parameter != profile.end())
ruleset_locality = parameter->second;
string ruleset_failure_domain = "host";
- parameter = parameters.find("ruleset-failure-domain");
- if (parameter != parameters.end())
+ parameter = profile.find("ruleset-failure-domain");
+ if (parameter != profile.end())
ruleset_failure_domain = parameter->second;
if (ruleset_locality != "") {
return 0;
}
-int ErasureCodeLrc::parse_ruleset(const map<string,string> ¶meters,
+int ErasureCodeLrc::parse_ruleset(ErasureCodeProfile &profile,
ostream *ss)
{
- map<string,string>::const_iterator parameter;
- parameter = parameters.find("ruleset-root");
- if (parameter != parameters.end())
+ ErasureCodeProfile::const_iterator parameter;
+ parameter = profile.find("ruleset-root");
+ if (parameter != profile.end())
ruleset_root = parameter->second;
- if (parameters.count("ruleset-steps") != 0) {
+ if (profile.count("ruleset-steps") != 0) {
ruleset_steps.clear();
- string str = parameters.find("ruleset-steps")->second;
+ string str = profile.find("ruleset-steps")->second;
json_spirit::mArray description;
try {
json_spirit::mValue json;
return 0;
}
-int ErasureCodeLrc::init(const map<string,string> ¶meters,
+int ErasureCodeLrc::init(ErasureCodeProfile &profile,
ostream *ss)
{
int r;
- map<string,string> parameters_rw = parameters;
- r = parse_kml(parameters_rw, ss);
+ r = parse_kml(profile, ss);
if (r)
return r;
- r = parse(parameters_rw, ss);
+ r = parse(profile, ss);
if (r)
return r;
json_spirit::mArray description;
- r = layers_description(parameters_rw, &description, ss);
+ r = layers_description(profile, &description, ss);
if (r)
return r;
- string description_string = parameters_rw.find("layers")->second;
+ string description_string = profile.find("layers")->second;
dout(10) << "init(" << description_string << ")" << dendl;
if (r)
return r;
- if (parameters_rw.count("mapping") == 0) {
- *ss << "the 'mapping' parameter is missing from " << parameters_rw;
+ if (profile.count("mapping") == 0) {
+ *ss << "the 'mapping' profile is missing from " << profile;
return ERROR_LRC_MAPPING;
}
- string mapping = parameters_rw.find("mapping")->second;
+ string mapping = profile.find("mapping")->second;
data_chunk_count = 0;
for(std::string::iterator it = mapping.begin(); it != mapping.end(); ++it) {
if (*it == 'D')
vector<int> chunks;
set<int> chunks_as_set;
string chunks_map;
- map<string,string> parameters;
+ ErasureCodeProfile profile;
};
vector<Layer> layers;
string directory;
const map<int, bufferlist> &chunks,
map<int, bufferlist> *decoded);
- int init(const map<string,string> ¶meters, ostream *ss);
+ virtual int init(ErasureCodeProfile &profile, ostream *ss);
- virtual int parse(const map<string,string> ¶meters, ostream *ss);
+ virtual int parse(ErasureCodeProfile &profile, ostream *ss);
- int parse_kml(map<string,string> ¶meters, ostream *ss);
+ int parse_kml(ErasureCodeProfile &profile, ostream *ss);
- int parse_ruleset(const map<string,string> ¶meters, ostream *ss);
+ int parse_ruleset(ErasureCodeProfile &profile, ostream *ss);
int parse_ruleset_step(string description_string,
json_spirit::mArray description,
ostream *ss);
- int layers_description(const map<string,string> ¶meters,
+ int layers_description(const ErasureCodeProfile &profile,
json_spirit::mArray *description,
ostream *ss) const;
int layers_parse(string description_string,
class ErasureCodePluginLrc : public ErasureCodePlugin {
public:
- virtual int factory(const map<std::string,std::string> ¶meters,
+ virtual int factory(ErasureCodeProfile &profile,
ErasureCodeInterfaceRef *erasure_code) {
ErasureCodeLrc *interface;
interface = new ErasureCodeLrc();
stringstream ss;
- assert(parameters.count("directory") != 0);
- int r = interface->init(parameters, &ss);
+ assert(profile.count("directory") != 0);
+ int r = interface->init(profile, &ss);
if (r) {
derr << ss.str() << dendl;
delete interface;
public:
ErasureCodeShecTableCache tcache;
- virtual int factory(const map<std::string,std::string> ¶meters,
+ virtual int factory(ErasureCodeProfile &profile,
ErasureCodeInterfaceRef *erasure_code) {
ErasureCodeShec *interface;
std::string t = "multiple";
- if (parameters.find("technique") != parameters.end()){
- t = parameters.find("technique")->second;
+ if (profile.find("technique") != profile.end()){
+ t = profile.find("technique")->second;
}
if (t == "single"){
<< dendl;
return -ENOENT;
}
- int err = interface->init(parameters);
- if (err) {
- return err;
+ int r = interface->init(profile);
+ if (r) {
+ return r;
}
*erasure_code = ErasureCodeInterfaceRef(interface);
}
}
-int ErasureCodeShec::init(const map<std::string,std::string> ¶meters)
+int ErasureCodeShec::init(ErasureCodeProfile &profile)
{
- dout(10) << "technique=" << technique << dendl;
map<string,string>::const_iterator parameter;
- parameter = parameters.find("ruleset-root");
- if (parameter != parameters.end())
+ parameter = profile.find("ruleset-root");
+ if (parameter != profile.end())
ruleset_root = parameter->second;
- parameter = parameters.find("ruleset-failure-domain");
- if (parameter != parameters.end())
+ parameter = profile.find("ruleset-failure-domain");
+ if (parameter != profile.end())
ruleset_failure_domain = parameter->second;
- int err = parse(parameters);
+ int err = parse(profile);
if (err) {
return err;
}
return k*w*sizeof(int);
}
-int ErasureCodeShecReedSolomonVandermonde::parse(const map<std::string,std::string> ¶meters)
+int ErasureCodeShecReedSolomonVandermonde::parse(const ErasureCodeProfile &profile)
{
int err = 0;
// k, m, c
- if (parameters.find("k") == parameters.end() &&
- parameters.find("m") == parameters.end() &&
- parameters.find("c") == parameters.end()){
+ if (profile.find("k") == profile.end() &&
+ profile.find("m") == profile.end() &&
+ profile.find("c") == profile.end()){
dout(10) << "(k, m, c) default to " << "(" << DEFAULT_K
<< ", " << DEFAULT_M << ", " << DEFAULT_C << ")" << dendl;
k = DEFAULT_K; m = DEFAULT_M; c = DEFAULT_C;
- } else if (parameters.find("k") == parameters.end() ||
- parameters.find("m") == parameters.end() ||
- parameters.find("c") == parameters.end()){
+ } else if (profile.find("k") == profile.end() ||
+ profile.find("m") == profile.end() ||
+ profile.find("c") == profile.end()){
dout(10) << "(k, m, c) must be choosed" << dendl;
err = -EINVAL;
} else {
std::string err_k, err_m, err_c, value_k, value_m, value_c;
- value_k = parameters.find("k")->second;
- value_m = parameters.find("m")->second;
- value_c = parameters.find("c")->second;
+ value_k = profile.find("k")->second;
+ value_m = profile.find("m")->second;
+ value_c = profile.find("c")->second;
k = strict_strtol(value_k.c_str(), 10, &err_k);
m = strict_strtol(value_m.c_str(), 10, &err_m);
c = strict_strtol(value_c.c_str(), 10, &err_c);
<< c << ")"<< dendl;
// w
- if (parameters.find("w") == parameters.end()){
+ if (profile.find("w") == profile.end()){
dout(10) << "w default to " << DEFAULT_W << dendl;
w = DEFAULT_W;
} else {
std::string err_w, value_w;
- value_w = parameters.find("w")->second;
+ value_w = profile.find("w")->second;
w = strict_strtol(value_w.c_str(), 10, &err_w);
if (!err_w.empty()){
const map<int, bufferlist> &chunks,
map<int, bufferlist> *decoded);
- int init(const map<std::string,std::string> ¶meters);
+ int init(ErasureCodeProfile &profile);
virtual void shec_encode(char **data,
char **coding,
int blocksize) = 0;
char **coding,
int blocksize) = 0;
virtual unsigned get_alignment() const = 0;
- virtual int parse(const map<std::string,std::string> ¶meters) = 0;
+ virtual int parse(const ErasureCodeProfile &profile) = 0;
virtual void prepare() = 0;
};
char **coding,
int blocksize);
virtual unsigned get_alignment() const;
- virtual int parse(const map<std::string,std::string> ¶meters);
+ virtual int parse(const ErasureCodeProfile &profile);
virtual void prepare();
};
{
if (pending_inc.has_erasure_code_profile(erasure_code_profile))
return -EAGAIN;
- const map<string,string> &profile =
+ ErasureCodeProfile profile =
osdmap.get_erasure_code_profile(erasure_code_profile);
- map<string,string>::const_iterator plugin =
+ ErasureCodeProfile::const_iterator plugin =
profile.find("plugin");
if (plugin == profile.end()) {
ss << "cannot determine the erasure code plugin"
- << " because there is no 'plugin' entry in the erasure_code_profile "
- << profile << std::endl;
+ << " because there is no 'plugin' entry in the erasure_code_profile "
+ << profile << std::endl;
return -EINVAL;
}
ErasureCodePluginRegistry &instance = ErasureCodePluginRegistry::instance();
}
case pg_pool_t::TYPE_ERASURE: {
ErasureCodeInterfaceRef ec_impl;
- const map<string,string> &profile = curmap->get_erasure_code_profile(pool.erasure_code_profile);
+ ErasureCodeProfile profile = curmap->get_erasure_code_profile(pool.erasure_code_profile);
assert(profile.count("plugin"));
stringstream ss;
ceph::ErasureCodePluginRegistry::instance().factory(
class ErasureCodePluginExample : public ErasureCodePlugin {
public:
- virtual int factory(const map<std::string,std::string> ¶meters,
+ virtual int factory(ErasureCodeProfile &profile,
ErasureCodeInterfaceRef *erasure_code)
{
*erasure_code = ErasureCodeInterfaceRef(new ErasureCodeExample());
{
ErasureCodeIsaDefault Isa(tcache);
- map<std::string, std::string> parameters;
- parameters["k"] = "2";
- parameters["m"] = "2";
- Isa.init(parameters);
+ ErasureCodeProfile profile;
+ profile["k"] = "2";
+ profile["m"] = "2";
+ Isa.init(profile);
string payload(object_size, 'X');
bufferlist in;
TEST_F(IsaErasureCodeTest, minimum_to_decode)
{
ErasureCodeIsaDefault Isa(tcache);
- map<std::string, std::string> parameters;
- parameters["k"] = "2";
- parameters["m"] = "2";
- Isa.init(parameters);
+ ErasureCodeProfile profile;
+ profile["k"] = "2";
+ profile["m"] = "2";
+ Isa.init(profile);
//
// If trying to read nothing, the minimum is empty.
{
{
ErasureCodeIsaDefault Isa(tcache);
- map<std::string, std::string> parameters;
- parameters["k"] = "2";
- parameters["m"] = "1";
- Isa.init(parameters);
+ ErasureCodeProfile profile;
+ profile["k"] = "2";
+ profile["m"] = "1";
+ Isa.init(profile);
int k = 2;
ASSERT_EQ(EC_ISA_ADDRESS_ALIGNMENT, Isa.get_chunk_size(1));
}
{
ErasureCodeIsaDefault Isa(tcache);
- map<std::string, std::string> parameters;
- parameters["k"] = "3";
- parameters["m"] = "1";
- Isa.init(parameters);
+ ErasureCodeProfile profile;
+ profile["k"] = "3";
+ profile["m"] = "1";
+ Isa.init(profile);
int k = 3;
ASSERT_EQ(EC_ISA_ADDRESS_ALIGNMENT, Isa.get_chunk_size(1));
TEST_F(IsaErasureCodeTest, encode)
{
ErasureCodeIsaDefault Isa(tcache);
- map<std::string, std::string> parameters;
- parameters["k"] = "2";
- parameters["m"] = "2";
- Isa.init(parameters);
+ ErasureCodeProfile profile;
+ profile["k"] = "2";
+ profile["m"] = "2";
+ Isa.init(profile);
unsigned aligned_object_size = Isa.get_alignment() * 2;
{
// a (12,4) configuration using the vandermonde matrix
ErasureCodeIsaDefault Isa(tcache);
- map<std::string, std::string> parameters;
- parameters["k"] = "12";
- parameters["m"] = "4";
- Isa.init(parameters);
+ ErasureCodeProfile profile;
+ profile["k"] = "12";
+ profile["m"] = "4";
+ Isa.init(profile);
int k = 12;
int m = 4;
// Test all possible failure scenarios and reconstruction cases for
// a (12,4) configuration using the cauchy matrix
ErasureCodeIsaDefault Isa(tcache,ErasureCodeIsaDefault::kCauchy);
- map<std::string, std::string> parameters;
- parameters["k"] = "12";
- parameters["m"] = "4";
- parameters["technique"] = "cauchy";
+ ErasureCodeProfile profile;
+ profile["k"] = "12";
+ profile["m"] = "4";
+ profile["technique"] = "cauchy";
- Isa.init(parameters);
+ Isa.init(profile);
int k = 12;
int m = 4;
// Test all possible failure scenarios and reconstruction cases for
// a (12,4) configuration using the cauchy matrix
ErasureCodeIsaDefault Isa(tcache,ErasureCodeIsaDefault::kCauchy);
- map<std::string, std::string> parameters;
- parameters["k"] = "16";
- parameters["m"] = "4";
- parameters["technique"] = "cauchy";
+ ErasureCodeProfile profile;
+ profile["k"] = "16";
+ profile["m"] = "4";
+ profile["technique"] = "cauchy";
- Isa.init(parameters);
+ Isa.init(profile);
int k = 16;
int m = 4;
// a (4,1) RAID-5 like configuration
ErasureCodeIsaDefault Isa(tcache);
- map<std::string, std::string> parameters;
- parameters["k"] = "4";
- parameters["m"] = "1";
- Isa.init(parameters);
+ ErasureCodeProfile profile;
+ profile["k"] = "4";
+ profile["m"] = "1";
+ Isa.init(profile);
int k = 4;
int m = 1;
{
stringstream ss;
ErasureCodeIsaDefault isa(tcache);
- map<std::string,std::string> parameters;
- parameters["k"] = "2";
- parameters["m"] = "2";
- parameters["w"] = "8";
- isa.init(parameters);
+ ErasureCodeProfile profile;
+ profile["k"] = "2";
+ profile["m"] = "2";
+ profile["w"] = "8";
+ isa.init(profile);
int ruleset = isa.create_ruleset("myrule", *c, &ss);
EXPECT_EQ(0, ruleset);
EXPECT_EQ(-EEXIST, isa.create_ruleset("myrule", *c, &ss));
{
stringstream ss;
ErasureCodeIsaDefault isa(tcache);
- map<std::string,std::string> parameters;
- parameters["k"] = "2";
- parameters["m"] = "2";
- parameters["w"] = "8";
- parameters["ruleset-root"] = "BAD";
- isa.init(parameters);
+ ErasureCodeProfile profile;
+ profile["k"] = "2";
+ profile["m"] = "2";
+ profile["w"] = "8";
+ profile["ruleset-root"] = "BAD";
+ isa.init(profile);
EXPECT_EQ(-ENOENT, isa.create_ruleset("otherrule", *c, &ss));
EXPECT_EQ("root item BAD does not exist", ss.str());
}
{
stringstream ss;
ErasureCodeIsaDefault isa(tcache);
- map<std::string,std::string> parameters;
- parameters["k"] = "2";
- parameters["m"] = "2";
- parameters["w"] = "8";
- parameters["ruleset-failure-domain"] = "WORSE";
- isa.init(parameters);
+ ErasureCodeProfile profile;
+ profile["k"] = "2";
+ profile["m"] = "2";
+ profile["w"] = "8";
+ profile["ruleset-failure-domain"] = "WORSE";
+ isa.init(profile);
EXPECT_EQ(-EINVAL, isa.create_ruleset("otherrule", *c, &ss));
EXPECT_EQ("unknown type WORSE", ss.str());
}
/*
* Local Variables:
* compile-command: "cd ../.. ; make -j4 unittest_erasure_code_isa &&
- * libtool --mode=execute valgrind --tool=memcheck --leak-check=full \
+ * libtool --mode=execute valgrind --tool=memcheck \
* ./unittest_erasure_code_isa \
* --gtest_filter=*.* --log-to-stderr=true --debug-osd=20"
* End:
per_chunk_alignment < 2;
per_chunk_alignment++) {
TypeParam jerasure;
- map<std::string,std::string> parameters;
- parameters["k"] = "2";
- parameters["m"] = "2";
- parameters["packetsize"] = "8";
- parameters["jerasure-per-chunk-alignment"] =
+ ErasureCodeProfile profile;
+ profile["k"] = "2";
+ profile["m"] = "2";
+ profile["packetsize"] = "8";
+ profile["jerasure-per-chunk-alignment"] =
per_chunk_alignments[per_chunk_alignment];
- jerasure.init(parameters);
+ jerasure.init(profile);
#define LARGE_ENOUGH 2048
bufferptr in_ptr(buffer::create_page_aligned(LARGE_ENOUGH));
TYPED_TEST(ErasureCodeTest, minimum_to_decode)
{
TypeParam jerasure;
- map<std::string,std::string> parameters;
- parameters["k"] = "2";
- parameters["m"] = "2";
- parameters["w"] = "7";
- parameters["packetsize"] = "8";
- jerasure.init(parameters);
+ ErasureCodeProfile profile;
+ profile["k"] = "2";
+ profile["m"] = "2";
+ profile["w"] = "7";
+ profile["packetsize"] = "8";
+ jerasure.init(profile);
//
// If trying to read nothing, the minimum is empty.
TEST(ErasureCodeTest, encode)
{
ErasureCodeJerasureReedSolomonVandermonde jerasure;
- map<std::string,std::string> parameters;
- parameters["k"] = "2";
- parameters["m"] = "2";
- parameters["w"] = "8";
- jerasure.init(parameters);
+ ErasureCodeProfile profile;
+ profile["k"] = "2";
+ profile["m"] = "2";
+ profile["w"] = "8";
+ jerasure.init(profile);
unsigned aligned_object_size = jerasure.get_alignment() * 2;
{
{
stringstream ss;
ErasureCodeJerasureReedSolomonVandermonde jerasure;
- map<std::string,std::string> parameters;
- parameters["k"] = "2";
- parameters["m"] = "2";
- parameters["w"] = "8";
- jerasure.init(parameters);
+ ErasureCodeProfile profile;
+ profile["k"] = "2";
+ profile["m"] = "2";
+ profile["w"] = "8";
+ jerasure.init(profile);
int ruleset = jerasure.create_ruleset("myrule", *c, &ss);
EXPECT_EQ(0, ruleset);
EXPECT_EQ(-EEXIST, jerasure.create_ruleset("myrule", *c, &ss));
{
stringstream ss;
ErasureCodeJerasureReedSolomonVandermonde jerasure;
- map<std::string,std::string> parameters;
- parameters["k"] = "2";
- parameters["m"] = "2";
- parameters["w"] = "8";
- parameters["ruleset-root"] = "BAD";
- jerasure.init(parameters);
+ ErasureCodeProfile profile;
+ profile["k"] = "2";
+ profile["m"] = "2";
+ profile["w"] = "8";
+ profile["ruleset-root"] = "BAD";
+ jerasure.init(profile);
EXPECT_EQ(-ENOENT, jerasure.create_ruleset("otherrule", *c, &ss));
EXPECT_EQ("root item BAD does not exist", ss.str());
}
{
stringstream ss;
ErasureCodeJerasureReedSolomonVandermonde jerasure;
- map<std::string,std::string> parameters;
- parameters["k"] = "2";
- parameters["m"] = "2";
- parameters["w"] = "8";
- parameters["ruleset-failure-domain"] = "WORSE";
- jerasure.init(parameters);
+ ErasureCodeProfile profile;
+ profile["k"] = "2";
+ profile["m"] = "2";
+ profile["w"] = "8";
+ profile["ruleset-failure-domain"] = "WORSE";
+ jerasure.init(profile);
EXPECT_EQ(-EINVAL, jerasure.create_ruleset("otherrule", *c, &ss));
EXPECT_EQ("unknown type WORSE", ss.str());
}
* Local Variables:
* compile-command: "cd ../.. ;
* make -j4 unittest_erasure_code_jerasure &&
- * valgrind --tool=memcheck --leak-check=full \
+ * valgrind --tool=memcheck \
* ./unittest_erasure_code_jerasure \
* --gtest_filter=*.* --log-to-stderr=true --debug-osd=20"
* End:
EXPECT_EQ("default", lrc.ruleset_root);
EXPECT_EQ("host", lrc.ruleset_steps.front().type);
- map<std::string,std::string> parameters;
- parameters["ruleset-root"] = "other";
- EXPECT_EQ(0, lrc.parse_ruleset(parameters, &cerr));
+ ErasureCodeProfile profile;
+ profile["ruleset-root"] = "other";
+ EXPECT_EQ(0, lrc.parse_ruleset(profile, &cerr));
EXPECT_EQ("other", lrc.ruleset_root);
- parameters["ruleset-steps"] = "[]";
- EXPECT_EQ(0, lrc.parse_ruleset(parameters, &cerr));
+ profile["ruleset-steps"] = "[]";
+ EXPECT_EQ(0, lrc.parse_ruleset(profile, &cerr));
EXPECT_TRUE(lrc.ruleset_steps.empty());
- parameters["ruleset-steps"] = "0";
- EXPECT_EQ(ERROR_LRC_ARRAY, lrc.parse_ruleset(parameters, &cerr));
+ profile["ruleset-steps"] = "0";
+ EXPECT_EQ(ERROR_LRC_ARRAY, lrc.parse_ruleset(profile, &cerr));
- parameters["ruleset-steps"] = "{";
- EXPECT_EQ(ERROR_LRC_PARSE_JSON, lrc.parse_ruleset(parameters, &cerr));
+ profile["ruleset-steps"] = "{";
+ EXPECT_EQ(ERROR_LRC_PARSE_JSON, lrc.parse_ruleset(profile, &cerr));
- parameters["ruleset-steps"] = "[0]";
- EXPECT_EQ(ERROR_LRC_ARRAY, lrc.parse_ruleset(parameters, &cerr));
+ profile["ruleset-steps"] = "[0]";
+ EXPECT_EQ(ERROR_LRC_ARRAY, lrc.parse_ruleset(profile, &cerr));
- parameters["ruleset-steps"] = "[[0]]";
- EXPECT_EQ(ERROR_LRC_RULESET_OP, lrc.parse_ruleset(parameters, &cerr));
+ profile["ruleset-steps"] = "[[0]]";
+ EXPECT_EQ(ERROR_LRC_RULESET_OP, lrc.parse_ruleset(profile, &cerr));
- parameters["ruleset-steps"] = "[[\"choose\", 0]]";
- EXPECT_EQ(ERROR_LRC_RULESET_TYPE, lrc.parse_ruleset(parameters, &cerr));
+ profile["ruleset-steps"] = "[[\"choose\", 0]]";
+ EXPECT_EQ(ERROR_LRC_RULESET_TYPE, lrc.parse_ruleset(profile, &cerr));
- parameters["ruleset-steps"] = "[[\"choose\", \"host\", []]]";
- EXPECT_EQ(ERROR_LRC_RULESET_N, lrc.parse_ruleset(parameters, &cerr));
+ profile["ruleset-steps"] = "[[\"choose\", \"host\", []]]";
+ EXPECT_EQ(ERROR_LRC_RULESET_N, lrc.parse_ruleset(profile, &cerr));
- parameters["ruleset-steps"] = "[[\"choose\", \"host\", 2]]";
- EXPECT_EQ(0, lrc.parse_ruleset(parameters, &cerr));
+ profile["ruleset-steps"] = "[[\"choose\", \"host\", 2]]";
+ EXPECT_EQ(0, lrc.parse_ruleset(profile, &cerr));
const ErasureCodeLrc::Step &step = lrc.ruleset_steps.front();
EXPECT_EQ("choose", step.op);
EXPECT_EQ("host", step.type);
EXPECT_EQ(2, step.n);
- parameters["ruleset-steps"] =
+ profile["ruleset-steps"] =
"["
" [\"choose\", \"rack\", 2], "
" [\"chooseleaf\", \"host\", 5], "
"]";
- EXPECT_EQ(0, lrc.parse_ruleset(parameters, &cerr));
+ EXPECT_EQ(0, lrc.parse_ruleset(profile, &cerr));
EXPECT_EQ(2U, lrc.ruleset_steps.size());
{
const ErasureCodeLrc::Step &step = lrc.ruleset_steps[0];
ErasureCodeLrc lrc;
EXPECT_EQ(0, lrc.create_ruleset("rule1", *c, &cerr));
- map<std::string,std::string> parameters;
+ ErasureCodeProfile profile;
unsigned int racks = 2;
unsigned int hosts = 5;
- parameters["ruleset-steps"] =
+ profile["ruleset-steps"] =
"["
" [\"choose\", \"rack\", " + stringify(racks) + "], "
" [\"chooseleaf\", \"host\", " + stringify(hosts) + "], "
"]";
const char *rule_name = "rule2";
- EXPECT_EQ(0, lrc.parse_ruleset(parameters, &cerr));
+ EXPECT_EQ(0, lrc.parse_ruleset(profile, &cerr));
EXPECT_EQ(1, lrc.create_ruleset(rule_name, *c, &cerr));
vector<__u32> weight;
TEST(ErasureCodeLrc, parse_kml)
{
ErasureCodeLrc lrc;
- map<std::string,std::string> parameters;
- EXPECT_EQ(0, lrc.parse_kml(parameters, &cerr));
- parameters["k"] = "4";
- EXPECT_EQ(ERROR_LRC_ALL_OR_NOTHING, lrc.parse_kml(parameters, &cerr));
+ ErasureCodeProfile profile;
+ EXPECT_EQ(0, lrc.parse_kml(profile, &cerr));
+ profile["k"] = "4";
+ EXPECT_EQ(ERROR_LRC_ALL_OR_NOTHING, lrc.parse_kml(profile, &cerr));
const char *generated[] = { "mapping",
"layers",
"ruleset-steps" };
- parameters["m"] = "2";
- parameters["l"] = "3";
+ profile["m"] = "2";
+ profile["l"] = "3";
for (int i = 0; i < 3; i++) {
- parameters[generated[i]] = "SET";
- EXPECT_EQ(ERROR_LRC_GENERATED, lrc.parse_kml(parameters, &cerr));
- parameters.erase(parameters.find(generated[i]));
+ profile[generated[i]] = "SET";
+ EXPECT_EQ(ERROR_LRC_GENERATED, lrc.parse_kml(profile, &cerr));
+ profile.erase(profile.find(generated[i]));
}
- parameters["k"] = "4";
- parameters["m"] = "2";
- parameters["l"] = "7";
- EXPECT_EQ(ERROR_LRC_K_M_MODULO, lrc.parse_kml(parameters, &cerr));
+ profile["k"] = "4";
+ profile["m"] = "2";
+ profile["l"] = "7";
+ EXPECT_EQ(ERROR_LRC_K_M_MODULO, lrc.parse_kml(profile, &cerr));
- parameters["k"] = "3";
- parameters["m"] = "3";
- parameters["l"] = "3";
- EXPECT_EQ(ERROR_LRC_K_MODULO, lrc.parse_kml(parameters, &cerr));
+ profile["k"] = "3";
+ profile["m"] = "3";
+ profile["l"] = "3";
+ EXPECT_EQ(ERROR_LRC_K_MODULO, lrc.parse_kml(profile, &cerr));
- parameters["k"] = "4";
- parameters["m"] = "2";
- parameters["l"] = "3";
- EXPECT_EQ(0, lrc.parse_kml(parameters, &cerr));
+ profile["k"] = "4";
+ profile["m"] = "2";
+ profile["l"] = "3";
+ EXPECT_EQ(0, lrc.parse_kml(profile, &cerr));
EXPECT_EQ("[ "
" [ \"DDc_DDc_\", \"\" ],"
" [ \"DDDc____\", \"\" ],"
" [ \"____DDDc\", \"\" ],"
- "]", parameters["layers"]);
- EXPECT_EQ("DD__DD__", parameters["mapping"]);
+ "]", profile["layers"]);
+ EXPECT_EQ("DD__DD__", profile["mapping"]);
EXPECT_EQ("chooseleaf", lrc.ruleset_steps[0].op);
EXPECT_EQ("host", lrc.ruleset_steps[0].type);
EXPECT_EQ(0, lrc.ruleset_steps[0].n);
EXPECT_EQ(1U, lrc.ruleset_steps.size());
- parameters.erase(parameters.find("mapping"));
- parameters.erase(parameters.find("layers"));
-
- parameters["k"] = "4";
- parameters["m"] = "2";
- parameters["l"] = "3";
- parameters["ruleset-failure-domain"] = "osd";
- EXPECT_EQ(0, lrc.parse_kml(parameters, &cerr));
+ profile.erase(profile.find("mapping"));
+ profile.erase(profile.find("layers"));
+
+ profile["k"] = "4";
+ profile["m"] = "2";
+ profile["l"] = "3";
+ profile["ruleset-failure-domain"] = "osd";
+ EXPECT_EQ(0, lrc.parse_kml(profile, &cerr));
EXPECT_EQ("chooseleaf", lrc.ruleset_steps[0].op);
EXPECT_EQ("osd", lrc.ruleset_steps[0].type);
EXPECT_EQ(0, lrc.ruleset_steps[0].n);
EXPECT_EQ(1U, lrc.ruleset_steps.size());
- parameters.erase(parameters.find("mapping"));
- parameters.erase(parameters.find("layers"));
-
- parameters["k"] = "4";
- parameters["m"] = "2";
- parameters["l"] = "3";
- parameters["ruleset-failure-domain"] = "osd";
- parameters["ruleset-locality"] = "rack";
- EXPECT_EQ(0, lrc.parse_kml(parameters, &cerr));
+ profile.erase(profile.find("mapping"));
+ profile.erase(profile.find("layers"));
+
+ profile["k"] = "4";
+ profile["m"] = "2";
+ profile["l"] = "3";
+ profile["ruleset-failure-domain"] = "osd";
+ profile["ruleset-locality"] = "rack";
+ EXPECT_EQ(0, lrc.parse_kml(profile, &cerr));
EXPECT_EQ("choose", lrc.ruleset_steps[0].op);
EXPECT_EQ("rack", lrc.ruleset_steps[0].type);
EXPECT_EQ(2, lrc.ruleset_steps[0].n);
EXPECT_EQ("osd", lrc.ruleset_steps[1].type);
EXPECT_EQ(4, lrc.ruleset_steps[1].n);
EXPECT_EQ(2U, lrc.ruleset_steps.size());
- parameters.erase(parameters.find("mapping"));
- parameters.erase(parameters.find("layers"));
+ profile.erase(profile.find("mapping"));
+ profile.erase(profile.find("layers"));
}
TEST(ErasureCodeLrc, layers_description)
{
ErasureCodeLrc lrc;
- map<std::string,std::string> parameters;
+ ErasureCodeProfile profile;
json_spirit::mArray description;
EXPECT_EQ(ERROR_LRC_DESCRIPTION,
- lrc.layers_description(parameters, &description, &cerr));
+ lrc.layers_description(profile, &description, &cerr));
{
const char *description_string = "\"not an array\"";
- parameters["layers"] = description_string;
+ profile["layers"] = description_string;
EXPECT_EQ(ERROR_LRC_ARRAY,
- lrc.layers_description(parameters, &description, &cerr));
+ lrc.layers_description(profile, &description, &cerr));
}
{
const char *description_string = "invalid json";
- parameters["layers"] = description_string;
+ profile["layers"] = description_string;
EXPECT_EQ(ERROR_LRC_PARSE_JSON,
- lrc.layers_description(parameters, &description, &cerr));
+ lrc.layers_description(profile, &description, &cerr));
}
{
const char *description_string = "[]";
- parameters["layers"] = description_string;
- EXPECT_EQ(0, lrc.layers_description(parameters, &description, &cerr));
+ profile["layers"] = description_string;
+ EXPECT_EQ(0, lrc.layers_description(profile, &description, &cerr));
}
}
{
{
ErasureCodeLrc lrc;
- map<std::string,std::string> parameters;
+ ErasureCodeProfile profile;
const char *description_string ="[ 0 ]";
- parameters["layers"] = description_string;
+ profile["layers"] = description_string;
json_spirit::mArray description;
- EXPECT_EQ(0, lrc.layers_description(parameters, &description, &cerr));
+ EXPECT_EQ(0, lrc.layers_description(profile, &description, &cerr));
EXPECT_EQ(ERROR_LRC_ARRAY,
lrc.layers_parse(description_string, description, &cerr));
}
{
ErasureCodeLrc lrc;
- map<std::string,std::string> parameters;
+ ErasureCodeProfile profile;
const char *description_string ="[ [ 0 ] ]";
- parameters["layers"] = description_string;
+ profile["layers"] = description_string;
json_spirit::mArray description;
- EXPECT_EQ(0, lrc.layers_description(parameters, &description, &cerr));
+ EXPECT_EQ(0, lrc.layers_description(profile, &description, &cerr));
EXPECT_EQ(ERROR_LRC_STR,
lrc.layers_parse(description_string, description, &cerr));
}
{
ErasureCodeLrc lrc;
- map<std::string,std::string> parameters;
+ ErasureCodeProfile profile;
const char *description_string ="[ [ \"\", 0 ] ]";
- parameters["layers"] = description_string;
+ profile["layers"] = description_string;
json_spirit::mArray description;
- EXPECT_EQ(0, lrc.layers_description(parameters, &description, &cerr));
+ EXPECT_EQ(0, lrc.layers_description(profile, &description, &cerr));
EXPECT_EQ(ERROR_LRC_CONFIG_OPTIONS,
lrc.layers_parse(description_string, description, &cerr));
}
//
// The second element can be an object describing the plugin
- // parameters.
+ // profile.
//
{
ErasureCodeLrc lrc;
- map<std::string,std::string> parameters;
+ ErasureCodeProfile profile;
const char *description_string ="[ [ \"\", { \"a\": \"b\" }, \"ignored\" ] ]";
- parameters["layers"] = description_string;
+ profile["layers"] = description_string;
json_spirit::mArray description;
- EXPECT_EQ(0, lrc.layers_description(parameters, &description, &cerr));
+ EXPECT_EQ(0, lrc.layers_description(profile, &description, &cerr));
EXPECT_EQ(0, lrc.layers_parse(description_string, description, &cerr));
- EXPECT_EQ("b", lrc.layers.front().parameters["a"]);
+ EXPECT_EQ("b", lrc.layers.front().profile["a"]);
}
//
// The second element can be a str_map parseable string describing the plugin
- // parameters.
+ // profile.
//
{
ErasureCodeLrc lrc;
- map<std::string,std::string> parameters;
+ ErasureCodeProfile profile;
const char *description_string ="[ [ \"\", \"a=b c=d\" ] ]";
- parameters["layers"] = description_string;
+ profile["layers"] = description_string;
json_spirit::mArray description;
- EXPECT_EQ(0, lrc.layers_description(parameters, &description, &cerr));
+ EXPECT_EQ(0, lrc.layers_description(profile, &description, &cerr));
EXPECT_EQ(0, lrc.layers_parse(description_string, description, &cerr));
- EXPECT_EQ("b", lrc.layers.front().parameters["a"]);
- EXPECT_EQ("d", lrc.layers.front().parameters["c"]);
+ EXPECT_EQ("b", lrc.layers.front().profile["a"]);
+ EXPECT_EQ("d", lrc.layers.front().profile["c"]);
}
}
{
{
ErasureCodeLrc lrc;
- map<std::string,std::string> parameters;
- parameters["mapping"] =
+ ErasureCodeProfile profile;
+ profile["mapping"] =
"__DDD__DD";
- parameters["directory"] = ".libs";
+ profile["directory"] = ".libs";
const char *description_string =
"[ "
" [ \"_cDDD_cDD\", \"\" ],"
" [ \"c_DDD____\", \"\" ],"
" [ \"_____cDDD\", \"\" ],"
"]";
- parameters["layers"] = description_string;
- EXPECT_EQ(0, lrc.init(parameters, &cerr));
+ profile["layers"] = description_string;
+ EXPECT_EQ(0, lrc.init(profile, &cerr));
}
{
ErasureCodeLrc lrc;
- map<std::string,std::string> parameters;
+ ErasureCodeProfile profile;
const char *description_string =
"[ "
"]";
- parameters["layers"] = description_string;
- EXPECT_EQ(ERROR_LRC_MAPPING, lrc.init(parameters, &cerr));
+ profile["layers"] = description_string;
+ EXPECT_EQ(ERROR_LRC_MAPPING, lrc.init(profile, &cerr));
}
{
ErasureCodeLrc lrc;
- map<std::string,std::string> parameters;
- parameters["mapping"] = "";
+ ErasureCodeProfile profile;
+ profile["mapping"] = "";
const char *description_string =
"[ "
"]";
- parameters["layers"] = description_string;
- EXPECT_EQ(ERROR_LRC_LAYERS_COUNT, lrc.init(parameters, &cerr));
+ profile["layers"] = description_string;
+ EXPECT_EQ(ERROR_LRC_LAYERS_COUNT, lrc.init(profile, &cerr));
}
{
ErasureCodeLrc lrc;
- map<std::string,std::string> parameters;
- parameters["directory"] = ".libs";
- parameters["mapping"] =
+ ErasureCodeProfile profile;
+ profile["directory"] = ".libs";
+ profile["mapping"] =
"AA";
const char *description_string =
"[ "
" [ \"AA\", \"\" ], "
" [ \"AA\", \"\" ], "
"]";
- parameters["layers"] = description_string;
- EXPECT_EQ(ERROR_LRC_MAPPING_SIZE, lrc.init(parameters, &cerr));
+ profile["layers"] = description_string;
+ EXPECT_EQ(ERROR_LRC_MAPPING_SIZE, lrc.init(profile, &cerr));
}
}
{
{
ErasureCodeLrc lrc;
- map<std::string,std::string> parameters;
+ ErasureCodeProfile profile;
const char *description_string =
"[ "
" [ \"_cDDD_cDD_\", \"directory=.libs\" ],"
"]";
- parameters["layers"] = description_string;
- parameters["directory"] = ".libs";
+ profile["layers"] = description_string;
+ profile["directory"] = ".libs";
json_spirit::mArray description;
- EXPECT_EQ(0, lrc.layers_description(parameters, &description, &cerr));
+ EXPECT_EQ(0, lrc.layers_description(profile, &description, &cerr));
EXPECT_EQ(0, lrc.layers_parse(description_string, description, &cerr));
EXPECT_EQ(0, lrc.layers_init());
- EXPECT_EQ("5", lrc.layers.front().parameters["k"]);
- EXPECT_EQ("2", lrc.layers.front().parameters["m"]);
- EXPECT_EQ("jerasure", lrc.layers.front().parameters["plugin"]);
- EXPECT_EQ("reed_sol_van", lrc.layers.front().parameters["technique"]);
+ EXPECT_EQ("5", lrc.layers.front().profile["k"]);
+ EXPECT_EQ("2", lrc.layers.front().profile["m"]);
+ EXPECT_EQ("jerasure", lrc.layers.front().profile["plugin"]);
+ EXPECT_EQ("reed_sol_van", lrc.layers.front().profile["technique"]);
}
}
TEST(ErasureCodeLrc, init)
{
ErasureCodeLrc lrc;
- map<std::string,std::string> parameters;
- parameters["mapping"] =
+ ErasureCodeProfile profile;
+ profile["mapping"] =
"__DDD__DD";
const char *description_string =
"[ "
" [ \"c_DDD____\", \"\" ],"
" [ \"_____cDDD\", \"\" ],"
"]";
- parameters["layers"] = description_string;
- parameters["directory"] = ".libs";
- EXPECT_EQ(0, lrc.init(parameters, &cerr));
+ profile["layers"] = description_string;
+ profile["directory"] = ".libs";
+ EXPECT_EQ(0, lrc.init(profile, &cerr));
}
TEST(ErasureCodeLrc, init_kml)
{
ErasureCodeLrc lrc;
- map<std::string,std::string> parameters;
- parameters["k"] = "4";
- parameters["m"] = "2";
- parameters["l"] = "3";
- parameters["directory"] = ".libs";
- EXPECT_EQ(0, lrc.init(parameters, &cerr));
+ ErasureCodeProfile profile;
+ profile["k"] = "4";
+ profile["m"] = "2";
+ profile["l"] = "3";
+ profile["directory"] = ".libs";
+ EXPECT_EQ(0, lrc.init(profile, &cerr));
EXPECT_EQ((unsigned int)(4 + 2 + (4 + 2) / 3), lrc.get_chunk_count());
}
// trivial : no erasures, the minimum is want_to_read
{
ErasureCodeLrc lrc;
- map<std::string,std::string> parameters;
- parameters["mapping"] =
+ ErasureCodeProfile profile;
+ profile["mapping"] =
"__DDD__DD";
const char *description_string =
"[ "
" [ \"c_DDD____\", \"\" ],"
" [ \"_____cDDD\", \"\" ],"
"]";
- parameters["layers"] = description_string;
- parameters["directory"] = ".libs";
- EXPECT_EQ(0, lrc.init(parameters, &cerr));
+ profile["layers"] = description_string;
+ profile["directory"] = ".libs";
+ EXPECT_EQ(0, lrc.init(profile, &cerr));
set<int> want_to_read;
want_to_read.insert(1);
set<int> available_chunks;
// locally repairable erasure
{
ErasureCodeLrc lrc;
- map<std::string,std::string> parameters;
- parameters["mapping"] =
+ ErasureCodeProfile profile;
+ profile["mapping"] =
"__DDD__DD_";
const char *description_string =
"[ "
" [ \"_____cDDD_\", \"\" ],"
" [ \"_____DDDDc\", \"\" ],"
"]";
- parameters["layers"] = description_string;
- parameters["directory"] = ".libs";
- EXPECT_EQ(0, lrc.init(parameters, &cerr));
- EXPECT_EQ(parameters["mapping"].length(),
+ profile["layers"] = description_string;
+ profile["directory"] = ".libs";
+ EXPECT_EQ(0, lrc.init(profile, &cerr));
+ EXPECT_EQ(profile["mapping"].length(),
lrc.get_chunk_count());
{
// want to read the last chunk
// implicit parity required
{
ErasureCodeLrc lrc;
- map<std::string,std::string> parameters;
- parameters["mapping"] =
+ ErasureCodeProfile profile;
+ profile["mapping"] =
"__DDD__DD";
const char *description_string =
"[ "
" [ \"c_DDD____\", \"\" ],"
" [ \"_____cDDD\", \"\" ],"
"]";
- parameters["layers"] = description_string;
- parameters["directory"] = ".libs";
- EXPECT_EQ(0, lrc.init(parameters, &cerr));
- EXPECT_EQ(parameters["mapping"].length(),
+ profile["layers"] = description_string;
+ profile["directory"] = ".libs";
+ EXPECT_EQ(0, lrc.init(profile, &cerr));
+ EXPECT_EQ(profile["mapping"].length(),
lrc.get_chunk_count());
set<int> want_to_read;
want_to_read.insert(8);
TEST(ErasureCodeLrc, encode_decode)
{
ErasureCodeLrc lrc;
- map<std::string,std::string> parameters;
- parameters["mapping"] =
+ ErasureCodeProfile profile;
+ profile["mapping"] =
"__DD__DD";
const char *description_string =
"[ "
" [ \"c_DD____\", \"\" ]," // first local layer
" [ \"____cDDD\", \"\" ]," // second local layer
"]";
- parameters["layers"] = description_string;
- parameters["directory"] = ".libs";
- EXPECT_EQ(0, lrc.init(parameters, &cerr));
+ profile["layers"] = description_string;
+ profile["directory"] = ".libs";
+ EXPECT_EQ(0, lrc.init(profile, &cerr));
EXPECT_EQ(4U, lrc.get_data_chunk_count());
unsigned int stripe_width = g_conf->osd_pool_erasure_code_stripe_width;
unsigned int chunk_size = stripe_width / lrc.get_data_chunk_count();
TEST(ErasureCodeLrc, encode_decode_2)
{
ErasureCodeLrc lrc;
- map<std::string,std::string> parameters;
- parameters["mapping"] =
+ ErasureCodeProfile profile;
+ profile["mapping"] =
"DD__DD__";
const char *description_string =
"[ "
" [ \"DDDc____\", \"\" ],"
" [ \"____DDDc\", \"\" ],"
"]";
- parameters["layers"] = description_string;
- parameters["directory"] = ".libs";
- EXPECT_EQ(0, lrc.init(parameters, &cerr));
+ profile["layers"] = description_string;
+ profile["directory"] = ".libs";
+ EXPECT_EQ(0, lrc.init(profile, &cerr));
EXPECT_EQ(4U, lrc.get_data_chunk_count());
unsigned int stripe_width = g_conf->osd_pool_erasure_code_stripe_width;
unsigned int chunk_size = stripe_width / lrc.get_data_chunk_count();
/*
* Local Variables:
* compile-command: "cd ../.. ;
- * make -j4 && valgrind --tool=memcheck --leak-check=full \
+ * make -j4 unittest_erasure_code_lrc && valgrind --tool=memcheck \
* ./unittest_erasure_code_lrc \
* --gtest_filter=*.* --log-to-stderr=true --debug-osd=20"
* End:
class Thread_factory : public Thread {
public:
virtual void *entry() {
- map<std::string,std::string> parameters;
- parameters["directory"] = ".libs";
+ ErasureCodeProfile profile;
+ profile["directory"] = ".libs";
ErasureCodePluginRegistry &instance = ErasureCodePluginRegistry::instance();
ErasureCodeInterfaceRef erasure_code;
stringstream ss;
- instance.factory("hangs", parameters, &erasure_code, ss);
+ instance.factory("hangs", profile, &erasure_code, ss);
return NULL;
}
};
TEST_F(ErasureCodePluginRegistryTest, all)
{
- map<std::string,std::string> parameters;
+ ErasureCodeProfile profile;
string directory(".libs");
- parameters["directory"] = directory;
+ profile["directory"] = directory;
ErasureCodeInterfaceRef erasure_code;
ErasureCodePluginRegistry &instance = ErasureCodePluginRegistry::instance();
stringstream ss;
EXPECT_FALSE(erasure_code);
- EXPECT_EQ(-EIO, instance.factory("invalid", parameters, &erasure_code, ss));
+ EXPECT_EQ(-EIO, instance.factory("invalid", profile, &erasure_code, ss));
EXPECT_FALSE(erasure_code);
- EXPECT_EQ(-EXDEV, instance.factory("missing_version", parameters,
+ EXPECT_EQ(-EXDEV, instance.factory("missing_version", profile,
&erasure_code, ss));
EXPECT_FALSE(erasure_code);
- EXPECT_EQ(-ENOENT, instance.factory("missing_entry_point", parameters,
+ EXPECT_EQ(-ENOENT, instance.factory("missing_entry_point", profile,
&erasure_code, ss));
EXPECT_FALSE(erasure_code);
- EXPECT_EQ(-ESRCH, instance.factory("fail_to_initialize", parameters,
+ EXPECT_EQ(-ESRCH, instance.factory("fail_to_initialize", profile,
&erasure_code, ss));
EXPECT_FALSE(erasure_code);
- EXPECT_EQ(-EBADF, instance.factory("fail_to_register", parameters,
+ EXPECT_EQ(-EBADF, instance.factory("fail_to_register", profile,
&erasure_code, ss));
EXPECT_FALSE(erasure_code);
- EXPECT_EQ(0, instance.factory("example", parameters, &erasure_code, ss));
+ EXPECT_EQ(0, instance.factory("example", profile, &erasure_code, ss));
EXPECT_TRUE(erasure_code);
ErasureCodePlugin *plugin = 0;
{
* Local Variables:
* compile-command: "cd ../.. ; make -j4 &&
* make unittest_erasure_code_plugin &&
- * valgrind --leak-check=full --tool=memcheck \
+ * valgrind --tool=memcheck \
* ./unittest_erasure_code_plugin \
* --gtest_filter=*.* --log-to-stderr=true --debug-osd=20"
* End:
TEST(ErasureCodePlugin, factory)
{
ErasureCodePluginRegistry &instance = ErasureCodePluginRegistry::instance();
- map<std::string,std::string> parameters;
- parameters["directory"] = ".libs";
+ ErasureCodeProfile profile;
+ profile["directory"] = ".libs";
{
ErasureCodeInterfaceRef erasure_code;
EXPECT_FALSE(erasure_code);
- EXPECT_EQ(-EIO, instance.factory("no-isa", parameters,
+ EXPECT_EQ(-EIO, instance.factory("no-isa", profile,
&erasure_code, cerr));
EXPECT_FALSE(erasure_code);
}
};
for(const char **technique = techniques; *technique; technique++) {
ErasureCodeInterfaceRef erasure_code;
- parameters["technique"] = *technique;
+ profile["technique"] = *technique;
EXPECT_FALSE(erasure_code);
- EXPECT_EQ(0, instance.factory("isa", parameters,
+ EXPECT_EQ(0, instance.factory("isa", profile,
&erasure_code, cerr));
EXPECT_TRUE(erasure_code);
}
TEST(ErasureCodePlugin, factory)
{
ErasureCodePluginRegistry &instance = ErasureCodePluginRegistry::instance();
- map<std::string,std::string> parameters;
- parameters["directory"] = ".libs";
+ ErasureCodeProfile profile;
+ profile["directory"] = ".libs";
{
ErasureCodeInterfaceRef erasure_code;
EXPECT_FALSE(erasure_code);
- EXPECT_EQ(-ENOENT, instance.factory("jerasure", parameters,
+ EXPECT_EQ(-ENOENT, instance.factory("jerasure", profile,
&erasure_code, cerr));
EXPECT_FALSE(erasure_code);
}
};
for(const char **technique = techniques; *technique; technique++) {
ErasureCodeInterfaceRef erasure_code;
- parameters["technique"] = *technique;
+ ErasureCodeProfile profile;
+ profile["directory"] = ".libs";
+ profile["technique"] = *technique;
EXPECT_FALSE(erasure_code);
- EXPECT_EQ(0, instance.factory("jerasure", parameters,
+ EXPECT_EQ(0, instance.factory("jerasure", profile,
&erasure_code, cerr));
EXPECT_TRUE(erasure_code);
}
int arch_neon = ceph_arch_neon;
ErasureCodePluginRegistry &instance = ErasureCodePluginRegistry::instance();
- map<std::string,std::string> parameters;
+ ErasureCodeProfile profile;
// load test plugins instead of actual plugins to assert the desired side effect
// happens
- parameters["jerasure-name"] = "test_jerasure";
- parameters["directory"] = ".libs";
- parameters["technique"] = "reed_sol_van";
+ profile["jerasure-name"] = "test_jerasure";
+ profile["directory"] = ".libs";
+ profile["technique"] = "reed_sol_van";
// all features are available, load the SSE4 plugin
{
ErasureCodeInterfaceRef erasure_code;
int sse4_side_effect = -444;
- EXPECT_EQ(sse4_side_effect, instance.factory("jerasure", parameters,
+ EXPECT_EQ(sse4_side_effect, instance.factory("jerasure", profile,
&erasure_code, cerr));
}
// pclmul is missing, load the SSE3 plugin
ErasureCodeInterfaceRef erasure_code;
int sse3_side_effect = -333;
- EXPECT_EQ(sse3_side_effect, instance.factory("jerasure", parameters,
+ EXPECT_EQ(sse3_side_effect, instance.factory("jerasure", profile,
&erasure_code, cerr));
}
// pclmul and sse3 are missing, load the generic plugin
ErasureCodeInterfaceRef erasure_code;
int generic_side_effect = -111;
- EXPECT_EQ(generic_side_effect, instance.factory("jerasure", parameters,
+ EXPECT_EQ(generic_side_effect, instance.factory("jerasure", profile,
&erasure_code, cerr));
}
// neon is set, load the neon plugin
ErasureCodeInterfaceRef erasure_code;
int generic_side_effect = -555;
- EXPECT_EQ(generic_side_effect, instance.factory("jerasure", parameters,
+ EXPECT_EQ(generic_side_effect, instance.factory("jerasure", profile,
&erasure_code, cerr));
}
in.push_front(in_ptr);
ErasureCodePluginRegistry &instance = ErasureCodePluginRegistry::instance();
- map<std::string,std::string> parameters;
- parameters["directory"] = ".libs";
- parameters["technique"] = "reed_sol_van";
- parameters["k"] = "2";
- parameters["m"] = "1";
+ ErasureCodeProfile profile;
+ profile["directory"] = ".libs";
+ profile["technique"] = "reed_sol_van";
+ profile["k"] = "2";
+ profile["m"] = "1";
for (vector<string>::iterator sse_variant = sse_variants.begin();
sse_variant != sse_variants.end();
++sse_variant) {
//
ErasureCodeInterfaceRef erasure_code;
EXPECT_FALSE(erasure_code);
- EXPECT_EQ(0, instance.factory("jerasure_" + *sse_variant, parameters,
+ EXPECT_EQ(0, instance.factory("jerasure_" + *sse_variant, profile,
&erasure_code, cerr));
EXPECT_TRUE(erasure_code);
TEST(ErasureCodePlugin, factory)
{
ErasureCodePluginRegistry &instance = ErasureCodePluginRegistry::instance();
- map<std::string,std::string> parameters;
- parameters["directory"] = ".libs";
- parameters["mapping"] = "DD_";
- parameters["layers"] = "[ [ \"DDc\", \"\" ] ]";
+ ErasureCodeProfile profile;
+ profile["directory"] = ".libs";
+ profile["mapping"] = "DD_";
+ profile["layers"] = "[ [ \"DDc\", \"\" ] ]";
ErasureCodeInterfaceRef erasure_code;
EXPECT_FALSE(erasure_code);
- EXPECT_EQ(0, instance.factory("lrc", parameters, &erasure_code, cerr));
+ EXPECT_EQ(0, instance.factory("lrc", profile, &erasure_code, cerr));
EXPECT_TRUE(erasure_code);
}
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["directory"] = "/usr/lib64/ceph/erasure-code";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
-
- int r = shec->init(*parameters);
-
//check parameters
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["directory"] = "/usr/lib64/ceph/erasure-code";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+
+ int r = shec->init(*profile);
+
EXPECT_EQ(6, shec->k);
EXPECT_EQ(4, shec->m);
EXPECT_EQ(3, shec->c);
EXPECT_EQ(0, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_2)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-root"] = "test";
- (*parameters)["ruleset-failure-domain"] = "host";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- (*parameters)["w"] = "8";
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-root"] = "test";
+ (*profile)["ruleset-failure-domain"] = "host";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ (*profile)["w"] = "8";
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
- //check parameters
+ //check profile
EXPECT_EQ(6, shec->k);
EXPECT_EQ(4, shec->m);
EXPECT_EQ(3, shec->c);
EXPECT_EQ(0, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_3)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- (*parameters)["w"] = "16";
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ (*profile)["w"] = "16";
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
- //check parameters
+ //check profile
EXPECT_EQ(6, shec->k);
EXPECT_EQ(4, shec->m);
EXPECT_EQ(3, shec->c);
EXPECT_EQ(0, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_4)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- (*parameters)["w"] = "32";
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ (*profile)["w"] = "32";
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
- //check parameters
+ //check profile
EXPECT_EQ(6, shec->k);
EXPECT_EQ(4, shec->m);
EXPECT_EQ(3, shec->c);
EXPECT_EQ(0, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_5)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
//plugin is not specified
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_TRUE(shec->matrix != NULL);
EXPECT_EQ(0, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_6)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "jerasure"; //unexpected value
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "jerasure"; //unexpected value
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_TRUE(shec->matrix != NULL);
EXPECT_EQ(0, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_7)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "abc"; //unexpected value
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "abc"; //unexpected value
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_TRUE(shec->matrix != NULL);
EXPECT_EQ(0, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_8)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["directory"] = "/usr/lib64/"; //unexpected value
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["directory"] = "/usr/lib64/"; //unexpected value
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_TRUE(shec->matrix != NULL);
EXPECT_EQ(0, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_9)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-root"] = "abc"; //unexpected value
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-root"] = "abc"; //unexpected value
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_TRUE(shec->matrix != NULL);
EXPECT_EQ(0, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_10)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "abc"; //unexpected value
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "abc"; //unexpected value
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_TRUE(shec->matrix != NULL);
EXPECT_EQ(0, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_11)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "abc"; //unexpected value
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "abc"; //unexpected value
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_TRUE(shec->matrix != NULL);
EXPECT_EQ(0, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_12)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "-1"; //unexpected value
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "-1"; //unexpected value
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_EQ(-EINVAL, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_13)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "abc";
- (*parameters)["k"] = "0.1"; //unexpected value
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "abc";
+ (*profile)["k"] = "0.1"; //unexpected value
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_EQ(-EINVAL, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_14)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "a"; //unexpected value
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "a"; //unexpected value
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_EQ(-EINVAL, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_15)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
//k is not specified
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_EQ(-EINVAL, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_16)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "-1"; //unexpected value
- (*parameters)["c"] = "3";
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "-1"; //unexpected value
+ (*profile)["c"] = "3";
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_EQ(-EINVAL, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_17)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "0.1"; //unexpected value
- (*parameters)["c"] = "3";
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "0.1"; //unexpected value
+ (*profile)["c"] = "3";
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_EQ(-EINVAL, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_18)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "a"; //unexpected value
- (*parameters)["c"] = "3";
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "a"; //unexpected value
+ (*profile)["c"] = "3";
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_EQ(-EINVAL, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_19)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
//m is not specified
- (*parameters)["c"] = "3";
+ (*profile)["c"] = "3";
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_EQ(-EINVAL, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_20)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "-1"; //unexpected value
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "-1"; //unexpected value
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_EQ(-EINVAL, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_21)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "0.1"; //unexpected value
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "0.1"; //unexpected value
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_EQ(-EINVAL, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_22)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "a"; //unexpected value
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "a"; //unexpected value
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_EQ(-EINVAL, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_23)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
//c is not specified
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_EQ(-EINVAL, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_24)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- (*parameters)["w"] = "1"; //unexpected value
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ (*profile)["w"] = "1"; //unexpected value
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_TRUE(shec->matrix != NULL);
EXPECT_EQ(0, r);
//w is default value
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_25)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- (*parameters)["w"] = "-1"; //unexpected value
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ (*profile)["w"] = "-1"; //unexpected value
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_TRUE(shec->matrix != NULL);
EXPECT_EQ(0, r);
//w is default value
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_26)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- (*parameters)["w"] = "0.1"; //unexpected value
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ (*profile)["w"] = "0.1"; //unexpected value
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_TRUE(shec->matrix != NULL);
EXPECT_EQ(0, r);
//w is default value
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_27)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- (*parameters)["w"] = "a"; //unexpected value
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ (*profile)["w"] = "a"; //unexpected value
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_TRUE(shec->matrix != NULL);
EXPECT_EQ(0, r);
//w is default value
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_28)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "10"; //c > m
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "10"; //c > m
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_EQ(-EINVAL, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_29)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
//k is not specified
//m is not specified
//c is not specified
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_TRUE(shec->matrix != NULL);
EXPECT_EQ(0, r);
EXPECT_EQ(2, shec->c);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_30)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "12";
- (*parameters)["m"] = "8";
- (*parameters)["c"] = "8";
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "12";
+ (*profile)["m"] = "8";
+ (*profile)["c"] = "8";
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_TRUE(shec->matrix != NULL);
EXPECT_EQ(0, r);
EXPECT_EQ(8, shec->c);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_31)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "13";
- (*parameters)["m"] = "7";
- (*parameters)["c"] = "7";
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "13";
+ (*profile)["m"] = "7";
+ (*profile)["c"] = "7";
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_EQ(-EINVAL, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_32)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "7";
- (*parameters)["m"] = "13";
- (*parameters)["c"] = "13";
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "7";
+ (*profile)["m"] = "13";
+ (*profile)["c"] = "13";
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_EQ(-EINVAL, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_33)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "12";
- (*parameters)["m"] = "9";
- (*parameters)["c"] = "8";
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "12";
+ (*profile)["m"] = "9";
+ (*profile)["c"] = "8";
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_EQ(-EINVAL, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init_34)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "8";
- (*parameters)["m"] = "12";
- (*parameters)["c"] = "12";
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "8";
+ (*profile)["m"] = "12";
+ (*profile)["c"] = "12";
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
EXPECT_EQ(-EINVAL, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init2_4)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
- int r = shec->init(*parameters); //init executed twice
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
+ int r = shec->init(*profile); //init executed twice
- //check parameters
+ //check profile
EXPECT_EQ(6, shec->k);
EXPECT_EQ(4, shec->m);
EXPECT_EQ(3, shec->c);
EXPECT_EQ(0, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, init2_5)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- map < std::string, std::string > *parameters2 = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "host";
- (*parameters)["k"] = "10";
- (*parameters)["m"] = "6";
- (*parameters)["c"] = "5";
- (*parameters)["w"] = "16";
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ ErasureCodeProfile *profile2 = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "host";
+ (*profile)["k"] = "10";
+ (*profile)["m"] = "6";
+ (*profile)["c"] = "5";
+ (*profile)["w"] = "16";
- int r = shec->init(*parameters);
+ int r = shec->init(*profile);
//reexecute init
- (*parameters2)["plugin"] = "shec";
- (*parameters2)["technique"] = "";
- (*parameters2)["ruleset-failure-domain"] = "osd";
- (*parameters2)["k"] = "6";
- (*parameters2)["m"] = "4";
- (*parameters2)["c"] = "3";
- shec->init(*parameters2);
+ (*profile2)["plugin"] = "shec";
+ (*profile2)["technique"] = "";
+ (*profile2)["ruleset-failure-domain"] = "osd";
+ (*profile2)["k"] = "6";
+ (*profile2)["m"] = "4";
+ (*profile2)["c"] = "3";
+ shec->init(*profile2);
EXPECT_EQ(6, shec->k);
EXPECT_EQ(4, shec->m);
EXPECT_EQ(0, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, minimum_to_decode_1)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//minimum_to_decode
set<int> want_to_decode;
EXPECT_TRUE(minimum_chunks.size());
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, minimum_to_decode_2)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//minimum_to_decode
set<int> want_to_decode;
EXPECT_TRUE(minimum_chunks.size());
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, minimum_to_decode_3)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//minimum_to_decode
set<int> want_to_decode;
EXPECT_EQ(0u, minimum_chunks.size());
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, minimum_to_decode_4)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//minimum_to_decode
set<int> want_to_decode;
EXPECT_EQ(-EINVAL, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, minimum_to_decode_5)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//minimum_to_decode
set<int> want_to_decode;
EXPECT_EQ(-EINVAL, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, minimum_to_decode_6)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//minimum_to_decode
set<int> want_to_decode;
EXPECT_EQ(-EINVAL, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, minimum_to_decode_7)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//minimum_to_decode
set<int> want_to_decode;
EXPECT_EQ(-EIO, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, minimum_to_decode_8)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//minimum_to_decode
set<int> want_to_decode;
EXPECT_EQ(-EINVAL, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, minimum_to_decode_9)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//minimum_to_decode
set<int> want_to_decode;
EXPECT_EQ(minimum, minimum_chunks);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, minimum_to_decode2_1)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//minimum_to_decode
set<int> want_to_decode;
EXPECT_TRUE(minimum_chunks.size());
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, minimum_to_decode2_3)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//minimum_to_decode
set<int> want_to_decode;
pthread_join(tid, NULL);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, minimum_to_decode_with_cost_1)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//minimum_to_decode_with_cost
set<int> want_to_decode;
EXPECT_TRUE(minimum_chunks.size());
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, minimum_to_decode_with_cost_2_3)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//minimum_to_decode_with_cost
set<int> want_to_decode;
pthread_join(tid, NULL);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, encode_1)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//encode
bufferlist in;
EXPECT_TRUE(usable == in);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, encode_2)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//encode
bufferlist in;
EXPECT_TRUE(usable == in);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, encode_3)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
bufferlist in;
in.append("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//length = 62
EXPECT_TRUE(usable == in);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, encode_4)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//encode
bufferlist in;
EXPECT_TRUE(usable == in);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, encode_8)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//encode
bufferlist in;
EXPECT_EQ(-EINVAL, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, encode_9)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//encode
bufferlist in;
EXPECT_EQ(-EINVAL, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, encode2_1)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//encode
bufferlist in;
EXPECT_TRUE(usable == in);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, encode2_3)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//encode
bufferlist in;
EXPECT_TRUE(usable == in);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, decode_1)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//encode
bufferlist in;
EXPECT_TRUE(usable == in);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, decode_2)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//encode
bufferlist in;
EXPECT_TRUE(usable == in);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, decode_3)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//encode
bufferlist in;
EXPECT_TRUE(usable == in);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, decode_4)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//encode
bufferlist in;
EXPECT_TRUE(usable == in);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, decode_7)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//encode
bufferlist in;
EXPECT_TRUE(usable == in);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, decode_8)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//encode
bufferlist in;
EXPECT_NE(0, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, decode_9)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//encode
bufferlist in;
EXPECT_NE(0, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, decode2_1)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//encode
bufferlist in;
EXPECT_TRUE(usable == in);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, decode2_3)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//encode
bufferlist in;
EXPECT_TRUE(usable == in);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, decode2_4)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//encode
bufferlist in;
EXPECT_EQ(-1, r);
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, create_ruleset_1_2)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//create_ruleset
stringstream ss;
EXPECT_EQ(-EEXIST, r);
delete shec;
- delete parameters;
+ delete profile;
delete crush;
}
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//create_ruleset
int r = shec->create_ruleset("myrule", *crush, NULL); //ss = NULL
EXPECT_EQ(0, r);
delete shec;
- delete parameters;
+ delete profile;
delete crush;
}
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//create_ruleset
stringstream ss;
EXPECT_STREQ("myrule", crush->rule_name_map[0].c_str());
delete shec;
- delete parameters;
+ delete profile;
delete crush;
}
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//create_ruleset
stringstream ss;
pthread_join(tid, NULL);
delete shec;
- delete parameters;
+ delete profile;
delete crush;
}
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//get_chunk_count
EXPECT_EQ(10u, shec->get_chunk_count());
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, get_data_chunk_count_1)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ shec->init(*profile);
//get_data_chunk_count
EXPECT_EQ(6u, shec->get_data_chunk_count());
delete shec;
- delete parameters;
+ delete profile;
}
TEST(ErasureCodeShec, get_chunk_size_1_2)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = "6";
- (*parameters)["m"] = "4";
- (*parameters)["c"] = "3";
- (*parameters)["w"] = "8";
- shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = "6";
+ (*profile)["m"] = "4";
+ (*profile)["c"] = "3";
+ (*profile)["w"] = "8";
+ shec->init(*profile);
//when there is no padding(192=k*w*4)
EXPECT_EQ(32u, shec->get_chunk_size(192));
EXPECT_EQ(32u, shec->get_chunk_size(190));
delete shec;
- delete parameters;
+ delete profile;
}
int main(int argc, char **argv)
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "";
- (*parameters)["directory"] = "/usr/lib64/ceph/erasure-code";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = k;
- (*parameters)["m"] = m;
- (*parameters)["c"] = c;
-
- result = shec->init(*parameters);
-
- //check parameters
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "";
+ (*profile)["directory"] = "/usr/lib64/ceph/erasure-code";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = k;
+ (*profile)["m"] = m;
+ (*profile)["c"] = c;
+
+ result = shec->init(*profile);
+
+ //check profile
EXPECT_EQ(i_k, shec->k);
EXPECT_EQ(i_m, shec->m);
EXPECT_EQ(i_c, shec->c);
EXPECT_EQ(c_size, shec->get_chunk_size(192));
delete shec;
- delete parameters;
+ delete profile;
delete crush;
}
ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
tcache,
ErasureCodeShec::MULTIPLE);
- map < std::string, std::string > *parameters = new map<std::string,
- std::string>();
- (*parameters)["plugin"] = "shec";
- (*parameters)["technique"] = "multiple";
- (*parameters)["ruleset-failure-domain"] = "osd";
- (*parameters)["k"] = param->k;
- (*parameters)["m"] = param->m;
- (*parameters)["c"] = param->c;
- (*parameters)["w"] = param->w;
- r = shec->init(*parameters);
+ ErasureCodeProfile *profile = new ErasureCodeProfile();
+ (*profile)["plugin"] = "shec";
+ (*profile)["technique"] = "multiple";
+ (*profile)["ruleset-failure-domain"] = "osd";
+ (*profile)["k"] = param->k;
+ (*profile)["m"] = param->m;
+ (*profile)["c"] = param->c;
+ (*profile)["w"] = param->w;
+ r = shec->init(*profile);
int i_k = std::atoi(param->k.c_str());
int i_m = std::atoi(param->m.c_str());
}
delete shec;
- delete parameters;
+ delete profile;
want_to_encode.clear();
encoded.clear();
decoded.clear();
class ErasureCodeCommand {
po::variables_map vm;
- map<string,string> parameters;
+ ErasureCodeProfile profile;
public:
int setup(int argc, char** argv);
int run();
cerr << "--parameter " << *i
<< " ignored because it does not contain exactly one =" << endl;
} else {
- parameters[strs[0]] = strs[1];
+ profile[strs[0]] = strs[1];
}
}
}
- if (parameters.count("directory") == 0)
- parameters["directory"] = ".libs";
+ if (profile.count("directory") == 0)
+ profile["directory"] = ".libs";
return 0;
}
ErasureCodePlugin *plugin = 0;
Mutex::Locker l(instance.lock);
stringstream ss;
- int code = instance.load(vm["plugin_exists"].as<string>(), parameters["directory"], &plugin, ss);
+ int code = instance.load(vm["plugin_exists"].as<string>(), profile["directory"], &plugin, &ss);
if (code)
cerr << ss.str() << endl;
return code;
ErasureCodePluginRegistry &instance = ErasureCodePluginRegistry::instance();
ErasureCodeInterfaceRef erasure_code;
- if (parameters.count("plugin") == 0) {
+ if (profile.count("plugin") == 0) {
cerr << "--parameter plugin=<plugin> is mandatory" << endl;
return 1;
}
- int code = instance.factory(parameters["plugin"],
- parameters,
+ int code = instance.factory(profile["plugin"],
+ profile,
&erasure_code, cerr);
if (code)
return code;
" (i.e. k=4,m=3 with one erasure will try to recover from the erasure of "
" the first chunk, then the second etc.)")
("parameter,P", po::value<vector<string> >(),
- "parameters")
+ "add a parameter to the erasure code profile")
;
po::variables_map vm;
if (strs.size() != 2) {
cerr << "--parameter " << *i << " ignored because it does not contain exactly one =" << endl;
} else {
- parameters[strs[0]] = strs[1];
+ profile[strs[0]] = strs[1];
}
}
}
- if (parameters.count("directory") == 0)
- parameters["directory"] = ".libs";
+ if (profile.count("directory") == 0)
+ profile["directory"] = ".libs";
in_size = vm["size"].as<int>();
max_iterations = vm["iterations"].as<int>();
if (vm.count("erased") > 0)
erased = vm["erased"].as<vector<int> >();
- k = atoi(parameters["k"].c_str());
- m = atoi(parameters["m"].c_str());
+ k = atoi(profile["k"].c_str());
+ m = atoi(profile["m"].c_str());
if (k <= 0) {
cout << "parameter k is " << k << ". But k needs to be > 0." << endl;
ErasureCodePluginRegistry &instance = ErasureCodePluginRegistry::instance();
ErasureCodeInterfaceRef erasure_code;
stringstream messages;
- int code = instance.factory(plugin, parameters, &erasure_code, messages);
+ int code = instance.factory(plugin, profile, &erasure_code, &messages);
if (code) {
cerr << messages.str() << endl;
return code;
ErasureCodePluginRegistry &instance = ErasureCodePluginRegistry::instance();
ErasureCodeInterfaceRef erasure_code;
stringstream messages;
- int code = instance.factory(plugin, parameters, &erasure_code, messages);
+ int code = instance.factory(plugin, profile, &erasure_code, &messages);
if (code) {
cerr << messages.str() << endl;
return code;
vector<int> erased;
string workload;
- map<string,string> parameters;
+ ErasureCodeProfile profile;
bool verbose;
public:
bool check;
string base;
string directory;
- map<string,string> parameters;
+ ErasureCodeProfile profile;
public:
int setup(int argc, char** argv);
int run();
("base", po::value<string>()->default_value("."),
"prefix all paths with base")
("parameter,P", po::value<vector<string> >(),
- "parameters")
+ "add a parameter to the erasure code profile")
("create", "create the erasure coded content in the directory")
("check", "check the content in the directory matches the chunks and vice versa")
;
if (strs.size() != 2) {
cerr << "--parameter " << *i << " ignored because it does not contain exactly one =" << endl;
} else {
- parameters[strs[0]] = strs[1];
+ profile[strs[0]] = strs[1];
}
if (strs[0] != "directory")
directory += " " + *i;
}
}
- if (parameters.count("directory") == 0)
- parameters["directory"] = ".libs";
+ if (profile.count("directory") == 0)
+ profile["directory"] = ".libs";
return 0;
}
ErasureCodePluginRegistry &instance = ErasureCodePluginRegistry::instance();
ErasureCodeInterfaceRef erasure_code;
stringstream messages;
- int code = instance.factory(plugin, parameters, &erasure_code, messages);
+ int code = instance.factory(plugin, profile, &erasure_code, &messages);
if (code) {
cerr << messages.str() << endl;
return code;
ErasureCodePluginRegistry &instance = ErasureCodePluginRegistry::instance();
ErasureCodeInterfaceRef erasure_code;
stringstream messages;
- int code = instance.factory(plugin, parameters, &erasure_code, messages);
+ int code = instance.factory(plugin, profile, &erasure_code, &messages);
if (code) {
cerr << messages.str() << endl;
return code;
projects / ceph.git / commitdiff