def load_items(context, id):
datastore = Configuration.load_configuration_datastore_version(context,
id)
config_items = ConfigurationParameter.find_all(configuration_id=id,
deleted=False).all()
rules = configurations.get_validation_rules(
datastore_manager=datastore.manager)
def _get_rule(key):
LOG.debug("finding rule with key : %s" % key)
for rule in rules['configuration-parameters']:
if str(rule.get('name')) == key:
return rule
filter_config_items = []
for item in config_items:
rule = _get_rule(str(item.configuration_key))
if rule:
if rule and rule.get('type') == 'boolean':
item.configuration_value = bool(int(item.configuration_value))
elif rule and rule.get('type') == 'integer':
item.configuration_value = int(item.configuration_value)
else:
item.configuration_value = str(item.configuration_value)
filter_config_items.append(item)
else:
pass
return filter_config_items
def index(self, req, tenant_id, datastore, id):
ds, ds_version = ds_models.get_datastore_version(
type=datastore, version=id)
rules = configurations.get_validation_rules(
datastore_manager=ds_version.manager)
return wsgi.Result(views.ConfigurationParametersView(rules).data(),
200)
def index(self, req, tenant_id, datastore, id):
ds, ds_version = ds_models.get_datastore_version(
type=datastore, version=id)
rules = configurations.get_validation_rules(
datastore_manager=ds_version.manager)
return wsgi.Result(views.ConfigurationParametersView(rules).data(),
200)
def show_by_version(self, req, tenant_id, version, name):
ds_version = ds_models.DatastoreVersion.load_by_uuid(version)
rules = configurations.get_validation_rules(
datastore_manager=ds_version.manager)
for rule in rules['configuration-parameters']:
if rule['name'] == name:
return wsgi.Result(
views.ConfigurationParametersView(rule).data(), 200)
raise exception.ConfigKeyNotFound(key=name)
def test_get_validation_rules(self):
rules = configurations.get_validation_rules("mysql")
# print json.dumps(rules, indent = 4)
self.assertTrue(rules != None and len(rules) > 0, rules)
def _get_not_exists():
rules = configurations.get_validation_rules("_not_exists_")
self.assertRaises(Exception, _get_not_exists)
def show_by_version(self, req, tenant_id, version, name):
ds_version = ds_models.DatastoreVersion.load_by_uuid(version)
rules = configurations.get_validation_rules(
datastore_manager=ds_version.manager)
for rule in rules['configuration-parameters']:
if rule['name'] == name:
return wsgi.Result(
views.ConfigurationParametersView(rule).data(), 200)
raise exception.ConfigKeyNotFound(key=name)
def _validate_configuration(values, datastore_manager=None):
rules = configurations.get_validation_rules(
datastore_manager=datastore_manager)
LOG.info(_("Validating configuration values"))
for k, v in values.iteritems():
# get the validation rule dictionary, which will ensure there is a
# rule for the given key name. An exception will be thrown if no
# valid rule is located.
rule = ConfigurationsController._get_item(
k, rules['configuration-parameters'])
if rule.get('deleted_at'):
raise exception.ConfigurationParameterDeleted(
parameter_name=rule.get('name'),
parameter_deleted_at=rule.get('deleted_at'))
# type checking
valueType = rule.get('type')
if not isinstance(v, ConfigurationsController._find_type(
valueType)):
output = {"key": k, "type": valueType}
msg = _("The value provided for the configuration "
"parameter %(key)s is not of type %(type)s.") % output
raise exception.UnprocessableEntity(message=msg)
# integer min/max checking
if isinstance(v, int):
try:
min_value = int(rule.get('min'))
except ValueError:
raise exception.TroveError(_(
"Invalid or unsupported min value defined in the "
"configuration-parameters configuration file. "
"Expected integer."))
if v < min_value:
output = {"key": k, "min": min_value}
message = _("The value for the configuration parameter "
"%(key)s is less than the minimum allowed: "
"%(min)s") % output
raise exception.UnprocessableEntity(message=message)
try:
max_value = int(rule.get('max'))
except ValueError:
raise exception.TroveError(_(
"Invalid or unsupported max value defined in the "
"configuration-parameters configuration file. "
"Expected integer."))
if v > max_value:
output = {"key": k, "max": max_value}
message = _("The value for the configuration parameter "
"%(key)s is greater than the maximum "
"allowed: %(max)s") % output
raise exception.UnprocessableEntity(message=message)
def show(self, req, tenant_id, datastore, id, name):
ds, ds_version = ds_models.get_datastore_version(
type=datastore, version=id)
rules = configurations.get_validation_rules(
datastore_manager=ds_version.manager)
for rule in rules['configuration-parameters']:
if rule['name'] == name:
return wsgi.Result(
views.ConfigurationParametersView(rule).data(), 200)
raise exception.ConfigKeyNotFound(key=name)
def show(self, req, tenant_id, datastore, id, name):
ds, ds_version = ds_models.get_datastore_version(
type=datastore, version=id)
rules = configurations.get_validation_rules(
datastore_manager=ds_version.manager)
for rule in rules['configuration-parameters']:
if rule['name'] == name:
return wsgi.Result(
views.ConfigurationParametersView(rule).data(), 200)
raise exception.ConfigKeyNotFound(key=name)
def default_config_items_update(self, id, value_file, config_name = None, description = None):
try:
self.db_api.configure_db(CONF)
context = TroveContext(tenant = CONF.default_template_tenant_id)
context.is_admin = True
group = config_models.KSC_Configuration.load(context, id)
'''
instances = instances_models.DBInstance.find_all(
tenant_id=context.tenant,
configuration_id=id,
deleted=False).all()
'''
# if name/description are provided in the request body, update the
# model with these values as well.
if config_name is not None:
group.name = config_name
if description is not None:
group.description = description
fmt_values = {}
if value_file is not None and os.path.isfile(value_file):
config = open(value_file).read()
cfg_parser = configurations.MySQLConfParser(config)
parsed = cfg_parser.parse()
values = dict(parsed)
rules = configurations.get_validation_rules(datastore_manager='mysql')
fmt_values = {}
for k, v in values.iteritems():
# get the validation rule dictionary, which will ensure there is a
# rule for the given key name. An exception will be thrown if no
# valid rule is located.
rule = config_service.ConfigurationsController._get_item(k, rules['configuration-parameters'])
valueType = rule.get('type')
if "integer" == valueType:
fmt_values[k] = int(v)
elif "boolean" == valueType:
fmt_values[k] = bool(v)
else:
fmt_values[k] = v
if len(fmt_values) > 0:
config_service.ConfigurationsController._validate_configuration(fmt_values, datastore_manager='mysql')
config_models.KSC_Configuration.remove_all_items(context,id, utils.utcnow())
items = config_models.KSC_Configuration.get_items_by_overrides(context,id, fmt_values)
config_models.KSC_Configuration.save(context, group, items, [])
except exception as e:
print(e)
def get_runtime_variables(self, req, tenant_id, id):
context = req.environ[wsgi.CONTEXT_KEY]
instance = models.Instance.load(context, id)
req_keys = req.GET.get('keys',None)
keys = []
if req_keys is not None:
keys = [elem for elem in req_keys.split(",") if elem != ""]
if len(keys) == 0:
rules = get_validation_rules()
config_params = rules['configuration-parameters']
keys = [item['name'] for item in config_params]
params = instance.get_runtime_variables(context,keys)
return wsgi.Result(RuntimeVariablesView(params).data(), 200)
def _render_override_config(self, flavor, overrides=None):
config = template.OverrideConfigTemplate(self.datastore_version, flavor, self.id)
rules = configurations.get_validation_rules(self.datastore_version.manager)
name2alias = {}
for rule in rules["configuration-parameters"]:
if rule.get("alias") is not None:
name2alias[rule.get("name")] = rule.get("alias")
if overrides is not None:
overrides_copy = overrides.copy()
for k, v in overrides.iteritems():
if name2alias.get(k) is not None:
del overrides_copy[k]
overrides_copy[name2alias.get(k)] = v
config.render(overrides=overrides_copy)
return config
def load_items(context, id):
datastore = Configuration.load_configuration_datastore_version(context, id)
config_items = ConfigurationParameter.find_all(configuration_id=id, deleted=False).all()
rules = configurations.get_validation_rules(datastore_manager=datastore.manager)
def _get_rule(key):
LOG.debug(_("finding rule with key : %s") % key)
for rule in rules["configuration-parameters"]:
if str(rule.get("name")) == key:
return rule
for item in config_items:
rule = _get_rule(str(item.configuration_key))
if rule.get("type") == "boolean":
item.configuration_value = bool(int(item.configuration_value))
elif rule.get("type") == "integer":
item.configuration_value = int(item.configuration_value)
else:
item.configuration_value = str(item.configuration_value)
return config_items
def load_items(context, id):
datastore = Configuration.load_configuration_datastore_version(
context, id)
config_items = ConfigurationParameter.find_all(configuration_id=id,
deleted=False).all()
rules = configurations.get_validation_rules(
datastore_manager=datastore.manager)
def _get_rule(key):
LOG.debug("finding rule with key : %s" % key)
for rule in rules['configuration-parameters']:
if str(rule.get('name')) == key:
return rule
for item in config_items:
rule = _get_rule(str(item.configuration_key))
if rule.get('type') == 'boolean':
item.configuration_value = bool(int(item.configuration_value))
elif rule.get('type') == 'integer':
item.configuration_value = int(item.configuration_value)
else:
item.configuration_value = str(item.configuration_value)
return config_items
def index_by_version(self, req, tenant_id, version):
ds_version = ds_models.DatastoreVersion.load_by_uuid(version)
rules = configurations.get_validation_rules(
datastore_manager=ds_version.manager)
return wsgi.Result(views.ConfigurationParametersView(rules).data(),
200)
def _get_not_exists():
rules = configurations.get_validation_rules("_not_exists_")
def validate_configuration(context, values, datastore_manager="mysql", instances=[], dynamic_param=False):
rules = configurations.get_validation_rules(datastore_manager=datastore_manager)
LOG.info(_("Validating configuration values"))
result = {}
for k, v in values.iteritems():
# get the validation rule dictionary, which will ensure there is a
# rule for the given key name. An exception will be thrown if no
# valid rule is located.
rule = ConfigurationsController._get_item(k, rules["configuration-parameters"])
exception_msg = []
if rule.get("deleted_at") and not dynamic_param:
output = {"parameter_name": rule.get("name"), "parameter_deleted_at": rule.get("deleted_at")}
message = (
_("%(parameter_name)s parameter can no longer be " " set as of %(parameter_deleted_at)s") % output
)
exception_msg.append(message)
# type checking
valueType = rule.get("type")
if isinstance(v, basestring):
v = patch_utils.convert_type(v)
"""ignore express type's validation when validate configuration"""
if valueType != "expression" and not dynamic_param:
value_type = KSC_ConfigurationsController._find_type(valueType)
if isinstance(value_type, tuple):
if not isinstance(v, value_type[0]) and not isinstance(v, value_type[1]):
output = {"key": k, "type": str(value_type)}
msg = (
_("The value provided for the configuration " "parameter %(key)s is not in type %(type)s.")
% output
)
exception_msg.append(msg)
else:
"""to handle the type is float and input is integer"""
if valueType == "float" and isinstance(v, int):
pass
elif not isinstance(v, KSC_ConfigurationsController._find_type(valueType)):
output = {"key": k, "type": valueType}
msg = (
_("The value provided for the configuration " "parameter %(key)s is not of type %(type)s.")
% output
)
exception_msg.append(msg)
if valueType == "expression" and not dynamic_param:
if not (isinstance(v, int) or isinstance(v, long)):
msg = (
_(
"The value provided for the configuration "
"parameter %s is neither integer nor long integer"
)
% k
)
exception_msg.append(msg)
# integer min/max checking
if (
valueType != "expression"
and (isinstance(v, int) or isinstance(v, float) or isinstance(v, long))
and not isinstance(v, bool)
and not dynamic_param
):
min_value = rule.get("min")
second_min_value = rule.get("second_min")
if not second_min_value:
if valueType != "expression" and v < min_value:
output = {"key": k, "min": min_value}
message = (
_(
"The value for the configuration parameter "
"%(key)s is less than the minimum allowed: "
"%(min)s"
)
% output
)
exception_msg.append(message)
else:
if valueType != "expression" and min_value < v < second_min_value:
output = {"key": k, "min": min_value, "second_min": second_min_value}
message = (
_(
"The value for the configuration parameter "
"%(key)s is greater than the minimun allowed: "
"%(min)s and less than the second minimum allowed: "
"%(second_min)s"
)
% output
)
exception_msg.append(message)
try:
max_value = rule.get("max")
except ValueError:
message = _(
"Invalid or unsupported max value defined in the "
"configuration-parameters configuration file. "
"Expected integer."
)
exception_msg.append(message)
if valueType != "expression" and v > max_value:
output = {"key": k, "max": max_value}
message = (
_(
"The value for the configuration parameter "
"%(key)s is greater than the maximum "
"allowed: %(max)s"
)
% output
)
exception_msg.append(message)
if isinstance(v, basestring) and not dynamic_param:
enum_itmes = rule.get("enums", None)
if enum_itmes != None:
valid_value = filter(lambda x: x.lower() == v.lower(), enum_itmes)
if valid_value == None or len(valid_value) == 0:
message = _("The string value %s is not a valid enum value. VALID ENUMS: %s" % (v, enum_itmes))
exception_msg.append(message)
# step checking
step = rule.get("step")
if valueType != "expression" and step:
min_value = rule.get("min")
recommended_value = ((v - min_value) / step) * step + min_value
if (v - min_value) % rule.get("step"):
output = {"key": k, "step": rule.get("step"), "recommended": recommended_value}
message = (
_(
"The value for the configuration parameter "
"%(key)s cannot be divisible by %(step)s "
"%(recommended)s is recommended"
)
% output
)
exception_msg.append(message)
"""validate expression value when the configuration attached"""
if valueType == "expression" and dynamic_param:
try:
max_value = rule.get("max")
except ValueError:
message = _(
"Invalid or unsupported max value defined in the "
"configuration-parameters configuration file. "
"Expected integer."
)
exception_msg.append(message)
inst_msg = []
for instance in instances:
value = KSC_ConfigurationsController._get_dynamic_value(context, max_value, instance)
if value and float(v) > value:
output = {"key": k, "max": value, "instance_name": instance.name}
message = (
_(
"The value for the configuration parameter "
"%(key)s is greater than the maximum "
"allowed: %(max)s on %(instance_name)s"
)
% output
)
inst_msg.append(message)
try:
min_value = rule.get("min")
except ValueError:
message = _(
"Invalid or unsupported min value defined in the "
"configuration-parameters configuration file. "
"Expected integer."
)
exception_msg.append(message)
for instance in instances:
value = KSC_ConfigurationsController._get_dynamic_value(context, min_value, instance)
if value and float(v) < value:
output = {"key": k, "min": value, "instance_name": instance.name}
message = (
_(
"The value for the configuration parameter "
"%(key)s is less than the minimum allowed: "
"%(min)s on %(instance_name)s"
)
% output
)
inst_msg.append(message)
if inst_msg:
exception_msg.append("".join(inst_msg))
else:
# step checking
step = rule.get("step")
if step and v % step:
output = {"key": k, "step": step}
message = (
_("The value for the configuration parameter " "%(key)s cannot be divisible by %(step)s")
% output
)
exception_msg.append(message)
if exception_msg:
result[rule.get("name")] = "".join(exception_msg)
return result
def index_by_version(self, req, tenant_id, version):
ds_version = ds_models.DatastoreVersion.load_by_uuid(version)
rules = configurations.get_validation_rules(
datastore_manager=ds_version.manager)
return wsgi.Result(views.ConfigurationParametersView(rules).data(),
200)
