void Quota::loadFromConfig(const String & config_elem, const String & name_, Poco::Util::AbstractConfiguration & config, pcg64 & rng) { name = name_; bool new_keyed_by_ip = config.has(config_elem + ".keyed_by_ip"); bool new_is_keyed = new_keyed_by_ip || config.has(config_elem + ".keyed"); if (new_is_keyed != is_keyed || new_keyed_by_ip != keyed_by_ip) { keyed_by_ip = new_keyed_by_ip; is_keyed = new_is_keyed; /// Meaning of keys has been changed. Throw away accumulated values. quota_for_keys.clear(); } ignore_key_if_not_keyed = config.has(config_elem + ".ignore_key_if_not_keyed"); QuotaForIntervals new_max(name, {}); new_max.initFromConfig(config_elem, config, rng); if (!new_max.hasEqualConfiguration(max)) { max = new_max; for (auto & quota : quota_for_keys) quota.second->setMax(max); } }
void SettingsConstraints::setProfile(const String & profile_name, const Poco::Util::AbstractConfiguration & config) { String parent_profile = "profiles." + profile_name + ".profile"; if (config.has(parent_profile)) setProfile(parent_profile, config); // Inheritance of one profile from another. String path_to_constraints = "profiles." + profile_name + ".constraints"; if (config.has(path_to_constraints)) loadFromConfig(path_to_constraints, config); }
void SettingsConstraints::loadFromConfig(const String & path_to_constraints, const Poco::Util::AbstractConfiguration & config) { if (!config.has(path_to_constraints)) throw Exception("There is no path '" + path_to_constraints + "' in configuration file.", ErrorCodes::NO_ELEMENTS_IN_CONFIG); Poco::Util::AbstractConfiguration::Keys names; config.keys(path_to_constraints, names); for (const String & name : names) { String path_to_name = path_to_constraints + "." + name; Poco::Util::AbstractConfiguration::Keys constraint_types; config.keys(path_to_name, constraint_types); for (const String & constraint_type : constraint_types) { auto get_constraint_value = [&]{ return config.getString(path_to_name + "." + constraint_type); }; if (constraint_type == "min") setMinValue(name, get_constraint_value()); else if (constraint_type == "max") setMaxValue(name, get_constraint_value()); else if (constraint_type == "readonly") setReadOnly(name, true); else throw Exception("Setting " + constraint_type + " value for " + name + " isn't supported", ErrorCodes::NOT_IMPLEMENTED); } } }
DictionaryLifetime::DictionaryLifetime(const Poco::Util::AbstractConfiguration & config, const std::string & config_prefix) { const auto & lifetime_min_key = config_prefix + ".min"; const auto has_min = config.has(lifetime_min_key); this->min_sec = has_min ? config.getInt(lifetime_min_key) : config.getInt(config_prefix); this->max_sec = has_min ? config.getInt(config_prefix + ".max") : this->min_sec; }
std::unique_ptr<RegionsHierarchies> GeoDictionariesLoader::reloadRegionsHierarchies( const Poco::Util::AbstractConfiguration & config) { static constexpr auto config_key = "path_to_regions_hierarchy_file"; if (!config.has(config_key)) return {}; const auto default_hierarchy_file = config.getString(config_key); auto data_provider = std::make_unique<RegionsHierarchiesDataProvider>(default_hierarchy_file); return std::make_unique<RegionsHierarchies>(std::move(data_provider)); }
std::unique_ptr<RegionsNames> GeoDictionariesLoader::reloadRegionsNames( const Poco::Util::AbstractConfiguration & config) { static constexpr auto config_key = "path_to_regions_names_files"; if (!config.has(config_key)) return {}; const auto directory = config.getString(config_key); auto data_provider = std::make_unique<RegionsNamesDataProvider>(directory); return std::make_unique<RegionsNames>(std::move(data_provider)); }
DictionaryStructure::DictionaryStructure(const Poco::Util::AbstractConfiguration & config, const std::string & config_prefix) { const auto has_id = config.has(config_prefix + ".id"); const auto has_key = config.has(config_prefix + ".key"); if (has_key && has_id) throw Exception{"Only one of 'id' and 'key' should be specified", ErrorCodes::BAD_ARGUMENTS}; if (has_id) id.emplace(config, config_prefix + ".id"); else if (has_key) { key.emplace(getAttributes(config, config_prefix + ".key", false, false)); if (key->empty()) throw Exception{"Empty 'key' supplied", ErrorCodes::BAD_ARGUMENTS}; } else throw Exception{"Dictionary structure should specify either 'id' or 'key'", ErrorCodes::BAD_ARGUMENTS}; if (id) { if (id->name.empty()) throw Exception{"'id' cannot be empty", ErrorCodes::BAD_ARGUMENTS}; if (config.has(config_prefix + ".range_min")) range_min.emplace(config, config_prefix + ".range_min"); if (config.has(config_prefix + ".range_max")) range_max.emplace(config, config_prefix + ".range_max"); if (!id->expression.empty() || (range_min && !range_min->expression.empty()) || (range_max && !range_max->expression.empty())) has_expressions = true; } attributes = getAttributes(config, config_prefix); if (attributes.empty()) throw Exception{"Dictionary has no attributes defined", ErrorCodes::BAD_ARGUMENTS}; }
void Settings::loadSettingsFromConfig(const String & path, const Poco::Util::AbstractConfiguration & config) { if (!config.has(path)) throw Exception("There is no path '" + path + "' in configuration file.", ErrorCodes::NO_ELEMENTS_IN_CONFIG); Poco::Util::AbstractConfiguration::Keys config_keys; config.keys(path, config_keys); for (const std::string & key : config_keys) { set(key, config.getString(path + "." + key)); } }
Pool::Pool(const Poco::Util::AbstractConfiguration & cfg, const std::string & config_name, unsigned default_connections_, unsigned max_connections_, const char * parent_config_name_) : default_connections(default_connections_), max_connections(max_connections_) { server = cfg.getString(config_name + ".host"); if (parent_config_name_) { const std::string parent_config_name(parent_config_name_); db = cfg.getString(config_name + ".db", cfg.getString(parent_config_name + ".db", "")); user = cfg.has(config_name + ".user") ? cfg.getString(config_name + ".user") : cfg.getString(parent_config_name + ".user"); password = cfg.has(config_name + ".password") ? cfg.getString(config_name + ".password") : cfg.getString(parent_config_name + ".password"); if (!cfg.has(config_name + ".port") && !cfg.has(config_name + ".socket") && !cfg.has(parent_config_name + ".port") && !cfg.has(parent_config_name + ".socket")) throw Poco::Exception("mysqlxx::Pool configuration: expected port or socket"); port = cfg.has(config_name + ".port") ? cfg.getInt(config_name + ".port") : cfg.getInt(parent_config_name + ".port", 0); socket = cfg.has(config_name + ".socket") ? cfg.getString(config_name + ".socket") : cfg.getString(parent_config_name + ".socket", ""); ssl_ca = cfg.has(config_name + ".ssl_ca") ? cfg.getString(config_name + ".ssl_ca") : cfg.getString(parent_config_name + ".ssl_ca", ""); ssl_cert = cfg.has(config_name + ".ssl_cert") ? cfg.getString(config_name + ".ssl_cert") : cfg.getString(parent_config_name + ".ssl_cert", ""); ssl_key = cfg.has(config_name + ".ssl_key") ? cfg.getString(config_name + ".ssl_key") : cfg.getString(parent_config_name + ".ssl_key", ""); } else { db = cfg.getString(config_name + ".db", ""); user = cfg.getString(config_name + ".user"); password = cfg.getString(config_name + ".password"); if (!cfg.has(config_name + ".port") && !cfg.has(config_name + ".socket")) throw Poco::Exception("mysqlxx::Pool configuration: expected port or socket"); port = cfg.getInt(config_name + ".port", 0); socket = cfg.getString(config_name + ".socket", ""); ssl_ca = cfg.getString(config_name + ".ssl_ca", ""); ssl_cert = cfg.getString(config_name + ".ssl_cert", ""); ssl_key = cfg.getString(config_name + ".ssl_key", ""); } connect_timeout = cfg.getInt(config_name + ".connect_timeout", cfg.getInt("mysql_connect_timeout", MYSQLXX_DEFAULT_TIMEOUT)); rw_timeout = cfg.getInt(config_name + ".rw_timeout", cfg.getInt("mysql_rw_timeout", MYSQLXX_DEFAULT_RW_TIMEOUT)); }