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_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):
lingam_schema = voluptuous.Schema({
"module": voluptuous.And(six.string_types[0],
vu.NoSpaceCharacter()),
"threshold": float
}, required=True)
return lingam_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):
stdout_schema = voluptuous.Schema(
{
"module":
voluptuous.And(six.string_types[0], vu.NoSpaceCharacter())
},
required=True)
stdout_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):
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)
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):
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(six.string_types[0],
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(six.string_types[0],
vu.ValidMarkovGraph()): [six.string_types[0]]
}
}, required=True)
return source_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_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)
def validate_config(_config):
cloud_schema = voluptuous.Schema({
"module": voluptuous.And(basestring, vu.NoSpaceCharacter())
}, required=True)
return cloud_schema(_config)
