def validate_config(_config):
base_schema = voluptuous.Schema({
"module": voluptuous.And(
basestring, lambda i: not any(c.isspace() for c in i)),
voluptuous.Optional("db_name"): voluptuous.And(
basestring, lambda i: not any(c.isspace() for c in i)),
}, required=True)
return base_schema(_config)
def validate_config(_config):
monasca_comb_schema = voluptuous.Schema(
{
"module":
voluptuous.And(basestring, vu.NoSpaceCharacter()),
"metric":
basestring,
"period":
voluptuous.And(
voluptuous.Or(float, int),
lambda i: i >= 0 and math.floor(i) == math.ceil(i)),
"lambda":
basestring,
"bindings": {
basestring:
voluptuous.Or(
"apache.net.kbytes_sec", "apache.net.requests_sec",
"apache.performance.cpu_load_perc", "cpu.idle_perc",
"cpu.stolen_perc", "cpu.system_perc",
"cpu.total_logical_cores", "cpu.user_perc",
"cpu.wait_perc", "disk.allocation",
"disk.inode_used_perc", "disk.space_used_perc",
"disk.total_space_mb", "disk.total_used_space_mb",
"host_alive_status", "io.read_kbytes_sec",
"io.read_req_sec", "io.write_time_sec",
"kafka.consumer_lag", "load.avg_1_min",
"load.avg_5_min", "mem.free_mb", "mem.swap_free_mb",
"mem.swap_total_mb", "mem.total_mb", "mem.usable_mb",
"mem.used_cache", "metrics-added-to-batch-counter[0]",
"mysql.innodb.buffer_pool_free",
"mysql.innodb.buffer_pool_used",
"mysql.innodb.data_reads",
"mysql.innodb.mutex_spin_rounds",
"mysql.performance.com_delete_multi",
"mysql.performance.com_insert",
"mysql.performance.com_insert_select",
"mysql.performance.com_select",
"mysql.performance.com_update",
"mysql.performance.created_tmp_disk_tables",
"mysql.performance.created_tmp_files",
"mysql.performance.open_files",
"mysql.performance.questions",
"mysql.performance.user_time", "net.in_bytes_sec",
"net.in_errors_sec", "net.in_packets_dropped_sec",
"net.in_packets_sec", "net.out_bytes_sec",
"net.out_errors_sec", "net.out_packets_dropped_sec",
"net.out_packets_sec",
"nova.vm.disk.total_allocated_gb", "process.pid_count",
"raw-sql.time.max", "vcpus", "vm.cpu.utilization_perc",
"vm.host_alive_status", "vm.mem.total_mb",
"zookeeper.out_bytes", "zookeeper.outstanding_bytes")
}
},
required=True)
monasca_comb_schema(_config)
# Checks the expression and the environment
handle = parsing.validate_expression(_config["lambda"])
parsing.validate_name_binding(handle, _config["bindings"])
def validate_config(_config):
markov_schema = voluptuous.Schema({
"module": voluptuous.And(six.string_types[0],
vu.NoSpaceCharacter()),
"sleep": voluptuous.And(
float, voluptuous.Range(
min=0, max=1, min_included=False, max_included=False)),
}, required=True)
return markov_schema(_config)
def validate_config(_config):
iptables_sql_schema = voluptuous.Schema(
{
"module":
voluptuous.And(basestring, vu.NoSpaceCharacter()),
voluptuous.Optional("db_name"):
voluptuous.And(basestring, vu.NoSpaceCharacter()),
},
required=True)
return iptables_sql_schema(_config)
def validate_config(_config):
pick_schema = voluptuous.Schema({
"module": voluptuous.And(
basestring, lambda i: not any(c.isspace() for c in i)),
"index": voluptuous.And(
voluptuous.Or(float, int),
lambda i: i >= 0 and math.ceil(i) == math.floor(i)
)
}, required=True)
return pick_schema(_config)
def validate_config(_config):
monasca_der_schema = voluptuous.Schema({
"module": voluptuous.And(six.string_types[0],
vu.NoSpaceCharacter()),
# Derivative period in multiple of batch interval
"period": voluptuous.And(
voluptuous.Or(float, int),
lambda i: i >= 0 and math.floor(i) == math.ceil(i))
}, required=True)
return monasca_der_schema(_config)
def validate_config(_config):
file_schema = voluptuous.Schema(
{
"module":
voluptuous.And(six.string_types[0], vu.NoSpaceCharacter()),
"path":
voluptuous.Or(
voluptuous.And(six.string_types[0], vu.ExistingPath()),
None)
},
required=True)
return file_schema(_config)
def validate_config(_config):
source_schema = voluptuous.Schema(
{
"module":
voluptuous.And(basestring, vu.NoSpaceCharacter()),
"sleep":
voluptuous.And(
float,
voluptuous.Range(
min=0, max=1, min_included=False, max_included=False)),
},
required=True)
return source_schema(_config)
def validate_kafka_sink_config(config):
"""Validates the KafkaSink configuration"""
config_schema = voluptuous.Schema({
"module": voluptuous.And(basestring, vu.AvailableSink()),
"host": voluptuous.And(
basestring, vu.NoSpaceCharacter()),
"port": voluptuous.And(
voluptuous.Or(float, int),
lambda i: i >= 0 and math.floor(i) == math.ceil(i)),
"topic": voluptuous.And(
basestring, vu.NoSpaceCharacter())
}, required=True)
return config_schema(config)
def validate_config(_config):
svm_schema = voluptuous.Schema({
"module": voluptuous.And(six.string_types[0],
vu.NoSpaceCharacter()),
"nb_samples": voluptuous.Or(float, int)
}, required=True)
return svm_schema(_config)
def validate_config(_config):
elliptic_schema = voluptuous.Schema({
'module': voluptuous.And(
basestring, NoSpaceCharacter()),
'nb_samples': voluptuous.Or(float, int)
}, required=True)
return elliptic_schema(_config)
def validate_config(_config):
lingam_schema = voluptuous.Schema({
"module": voluptuous.And(six.string_types[0],
vu.NoSpaceCharacter()),
"threshold": float
}, required=True)
return lingam_schema(_config)
def action_model(value):
"""Validates the data against action_model schema."""
action_model_schema = voluptuous.Schema({
"action": voluptuous.And(basestring, lambda o: not o.startswith("_"))
}, required=True)
return action_model_schema(value)
def validate_config(_config):
decisiontree_schema = voluptuous.Schema({
'module': voluptuous.And(six.string_types[0],
NoSpaceCharacter()),
'nb_samples': voluptuous.Or(float, int)
}, required=True)
return decisiontree_schema(_config)
def validate_config(_config):
stdout_schema = voluptuous.Schema(
{
"module":
voluptuous.And(six.string_types[0], vu.NoSpaceCharacter())
},
required=True)
stdout_schema(_config)
def validate_config(_config):
cloud_causality_schema = voluptuous.Schema(
{
"module":
voluptuous.And(six.string_types[0], vu.NoSpaceCharacter())
},
required=True)
return cloud_causality_schema(_config)
def validate_config(_config):
source_schema = voluptuous.Schema(
{
"module": voluptuous.And(basestring, vu.NoSpaceCharacter()),
"params": {
"zk_host": voluptuous.And(basestring,
vu.NoSpaceCharacter()),
"zk_port": int,
"group_id": voluptuous.And(basestring,
vu.NoSpaceCharacter()),
"topics": {
voluptuous.And(basestring, vu.NoSpaceCharacter()):
voluptuous.And(int, voluptuous.Range(min=1))
}
}
},
required=True)
return source_schema(_config)
def validate_config(_config):
monasca_ag_schema = voluptuous.Schema(
{
"module": voluptuous.And(basestring, vu.NoSpaceCharacter()),
"period": voluptuous.Or(float, int),
"func": voluptuous.Or("avg", "max", "sum", "min", "cnt")
},
required=True)
return monasca_ag_schema(_config)
class _PostGameInput:
valid_id = vol.And(str, vol.Coerce(int))
valid_score = vol.And(str, vol.Coerce(int))
class Keys:
white_id = 'white_id'
black_id = 'black_id'
white_score = 'white_score'
black_score = 'black_score'
hash_ = 'hash'
schema = vol.Schema(
{
Keys.white_id: valid_id,
Keys.black_id: valid_id,
Keys.white_score: valid_score,
Keys.black_score: valid_score,
Keys.hash_: str,
},
required=True,
extra=vol.ALLOW_EXTRA)
def UserConfigurationSchema(
config: typing.Dict[str, typing.Any],
partial_validation: bool = False) -> voluptuous.Schema:
schema = {
voluptuous.Required("pull_request_rules", default=[]):
get_pull_request_rules_schema(partial_validation),
voluptuous.Required("queue_rules", default=[]):
QueueRulesSchema,
voluptuous.Required("defaults", default={}):
get_defaults_schema(partial_validation),
}
if not partial_validation:
schema = voluptuous.And(schema,
voluptuous.Coerce(FullifyPullRequestRules))
return voluptuous.Schema(schema)(config)
def validate_config(_config):
source_schema = voluptuous.Schema(
{
"module":
voluptuous.And(six.string_types[0], vu.NoSpaceCharacter()),
"params": {
"host":
voluptuous.And(six.string_types[0], vu.NoSpaceCharacter()),
"port":
int,
"model": {
"name":
voluptuous.And(six.string_types[0],
vu.NoSpaceCharacter()),
"params": {
"origin_types":
voluptuous.And([{
"origin_type":
voluptuous.And(six.string_types[0],
vu.NoSpaceCharacter()),
"weight":
voluptuous.And(
voluptuous.Or(int, float),
voluptuous.Range(min=0,
min_included=False)),
}], vu.NotEmptyArray()),
voluptuous.Optional("key_causes"):
dict
}
},
"alerts_per_burst":
voluptuous.And(int, voluptuous.Range(min=1)),
"idle_time_between_bursts":
voluptuous.And(voluptuous.Or(int, float),
voluptuous.Range(min=0, min_included=False))
}
},
required=True)
return source_schema(_config)
pass
@voluptuous.message("expected a Pull Request URL", cls=PullRequestUrlInvalid)
def PullRequestUrl(v):
_, owner, repo, _, pull_number = urlsplit(v).path.split("/")
pull_number = int(pull_number)
return owner, repo, pull_number
SimulatorSchema = voluptuous.Schema({
voluptuous.Required("pull_request"):
voluptuous.Any(None, PullRequestUrl()),
voluptuous.Required("mergify.yml"):
voluptuous.And(
voluptuous.Coerce(rules.YAML),
rules.UserConfigurationSchema,
),
})
def voluptuous_error(error):
if error.path:
if error.path[0] == "mergify.yml":
error.path.pop(0)
return str(rules.InvalidRules(error, ""))
@app.exception_handler(voluptuous.Invalid)
async def voluptuous_errors(request: requests.Request,
exc: voluptuous.Invalid) -> responses.JSONResponse:
# Replace payload by our own
voluptuous.All(str, voluptuous.Coerce(RuleCondition))
],
voluptuous.Required("actions"): actions.get_action_schemas(),
},
voluptuous.Coerce(Rule.from_dict),
),
],
voluptuous.Length(min=1),
voluptuous.Coerce(PullRequestRules),
)
UserConfigurationSchema = voluptuous.Schema(
voluptuous.And(
voluptuous.Coerce(YAML),
{
voluptuous.Required("pull_request_rules"): PullRequestRulesSchema,
},
)
)
class NoRules(Exception):
def __init__(self):
super().__init__("Mergify configuration file is missing")
@dataclasses.dataclass
class InvalidRules(Exception):
error: voluptuous.Invalid
filename: str
for pr_rule in v["pull_request_rules"]:
for action in pr_rule.actions.values():
action.validate_config(v)
except voluptuous.error.Error:
raise
except Exception as e:
LOG.error("fail to dispatch config", exc_info=True)
raise voluptuous.error.Invalid(str(e))
return v
UserConfigurationSchema = voluptuous.Schema(
voluptuous.And(
{
voluptuous.Required("pull_request_rules"): PullRequestRulesSchema,
voluptuous.Required("queue_rules", default=[]): QueueRulesSchema,
voluptuous.Required("defaults", default={}): DefaultsSchema,
},
voluptuous.Coerce(FullifyPullRequestRules),
))
YamlSchema = voluptuous.Schema(voluptuous.Coerce(YAML))
@dataclasses.dataclass
class InvalidRules(Exception):
error: voluptuous.Invalid
filename: str
@staticmethod
def _format_path_item(path_item):
if isinstance(path_item, int):
class PullRequestUrlInvalid(voluptuous.Invalid): # type: ignore[misc]
pass
@voluptuous.message("expected a Pull Request URL", cls=PullRequestUrlInvalid)
def PullRequestUrl(v):
_, owner, repo, _, pull_number = urlsplit(v).path.split("/")
pull_number = int(pull_number)
return owner, repo, pull_number
SimulatorSchema = voluptuous.Schema(
{
voluptuous.Required("pull_request"): voluptuous.Any(None, PullRequestUrl()),
voluptuous.Required("mergify.yml"): voluptuous.And(
voluptuous.Coerce(rules.YAML),
rules.UserConfigurationSchema,
),
}
)
def voluptuous_error(error):
if error.path:
if error.path[0] == "mergify.yml":
error.path.pop(0)
return str(rules.InvalidRules(error, ""))
@app.exception_handler(voluptuous.Invalid)
async def voluptuous_errors(
request: requests.Request, exc: voluptuous.Invalid
def validate_config(_config):
cloud_schema = voluptuous.Schema({
"module": voluptuous.And(basestring, vu.NoSpaceCharacter())
}, required=True)
return cloud_schema(_config)
def validate_config(_config):
source_schema = voluptuous.Schema(
{
"module":
voluptuous.And(basestring, vu.NoSpaceCharacter()),
"min_event_per_burst":
voluptuous.Or(float, int),
"sleep":
voluptuous.And(
float,
voluptuous.Range(
min=0, max=1, min_included=False, max_included=False)),
"transitions": {
"web_service": {
"run=>slow": {
voluptuous.And(vu.NumericString()):
voluptuous.And(voluptuous.Or(int, float),
voluptuous.Range(min=0, max=1)),
},
"slow=>run": {
voluptuous.And(vu.NumericString()):
voluptuous.And(voluptuous.Or(int, float),
voluptuous.Range(min=0, max=1)),
},
"stop=>run":
voluptuous.And(voluptuous.Or(int, float),
voluptuous.Range(min=0, max=1)),
},
"switch": {
"on=>off":
voluptuous.And(voluptuous.Or(int, float),
voluptuous.Range(min=0, max=1)),
"off=>on":
voluptuous.And(voluptuous.Or(int, float),
voluptuous.Range(min=0, max=1)),
},
"host": {
"on=>off":
voluptuous.And(voluptuous.Or(int, float),
voluptuous.Range(min=0, max=1)),
"off=>on":
voluptuous.And(voluptuous.Or(int, float),
voluptuous.Range(min=0, max=1)),
},
},
"triggers": {
"support": {
"get_called": {
voluptuous.And(vu.NumericString()):
voluptuous.And(voluptuous.Or(int, float),
voluptuous.Range(min=0, max=1)),
},
},
},
"graph": {
voluptuous.And(basestring, vu.ValidMarkovGraph()):
[basestring]
}
},
required=True)
return source_schema(_config)
path = (
[types.LineColumnPath(e.problem_mark.line + 1, e.problem_mark.column + 1)]
if hasattr(e, "problem_mark")
else None
)
raise YAMLInvalid(
message="Invalid YAML", error_message=error_message, path=path
)
return v
UserConfigurationSchema = voluptuous.Schema(
voluptuous.And(
voluptuous.Coerce(YAML),
{
voluptuous.Required("pull_request_rules"): voluptuous.Coerce(
PullRequestRules.from_list
)
},
)
)
class NoRules(Exception):
def __init__(self):
super().__init__("Mergify configuration file is missing")
@dataclasses.dataclass
class InvalidRules(Exception):
error: voluptuous.Invalid
filename: str
def _validate_schema(config):
"""Validate the configuration, with spark, up to the orchestration level
Checks that hte spark configuration is valid, as well as the modules
structure in the configuration up to the orchestration level.
Each module will be responsible to validate its own sub-configuration.
:type config: dict
:param config: configuration model for the whole system
:raises: SchemaError -- if the configuration, up to the
orchestration level, is not valid
"""
config_schema = voluptuous.Schema(
{
"spark_config": {
"appName": basestring,
"streaming": {
"batch_interval": voluptuous.And(int,
voluptuous.Range(min=1))
}
},
"server": {
"port": int,
"debug": bool
},
"sources": {
voluptuous.Optional(basestring): {
basestring: object
}
},
"ingestors": {
voluptuous.Optional(basestring): {
basestring: object
}
},
"smls": {
voluptuous.Optional(basestring): {
basestring: object
}
},
"voters": {
voluptuous.Optional(basestring): {
basestring: object
}
},
"sinks": {
voluptuous.Optional(basestring): {
basestring: object
}
},
"ldps": {
voluptuous.Optional(basestring): {
basestring: object
}
},
"connections": {
voluptuous.Optional(basestring): [basestring]
},
"feedback": {
voluptuous.Optional(basestring): [basestring]
}
},
required=True)
return config_schema(config)
