def test_reversed_list(self):
""" Test to ensure new conf is properly merge with different servicegroup definition
The first conf has all its servicegroup defined servicegroups.cfg and services.cfg
The second conf has both, so that servicegroups defined ins services.cfg are genretaed by Alignak
This lead to another generated id witch should be handled properly when regenerating reversed list / merging
servicegroups definition
"""
sg = self.sched.servicegroups.find_by_name('servicegroup_01')
prev_id = sg._id
reg = Regenerator()
data = {"instance_id": 0}
b = Brok('program_status', data)
b.prepare()
reg.manage_program_status_brok(b)
reg.all_done_linking(0)
self.setup_with_file(["etc/alignak_reversed_list.cfg"])
reg.all_done_linking(0)
#for service in self.sched.servicegroups:
# assert(service.servicegroup_name in self.sched.servicegroups.reversed_list.keys())
# assert(service._id == self.sched.servicegroups.reversed_list[service.servicegroup_name])
sg = self.sched.servicegroups.find_by_name('servicegroup_01')
assert(prev_id != sg._id)
for sname in [u'servicegroup_01', u'ok', u'flap', u'unknown', u'random',
u'servicegroup_02', u'servicegroup_03', u'warning', u'critical',
u'servicegroup_04', u'servicegroup_05', u'pending', u'mynewgroup']:
sg = self.sched.servicegroups.find_by_name(sname)
assert(sname is not None)
def get_initial_status_brok(self, items=None): # pylint:disable=W0221
"""
Get a brok with hostgroup info (like id, name)
Members contain list of (id, host_name)
:param items: monitoring items, used to recover members
:type items: alignak.objects.item.Items
:return:Brok object
:rtype: object
"""
cls = self.__class__
data = {}
# Now config properties
for prop, entry in cls.properties.items():
if entry.fill_brok != []:
if hasattr(self, prop):
data[prop] = getattr(self, prop)
# Here members is just a bunch of host, I need name in place
data['members'] = []
for m_id in self.members:
member = items[m_id]
# it look like lisp! ((( ..))), sorry....
data['members'].append((member.uuid, member.get_name()))
brok = Brok({
'type': 'initial_' + cls.my_type + '_status',
'data': data
})
return brok
def emit(self, record):
try:
msg = self.format(record)
brok = Brok('log', {'log': msg + '\n'})
self._broker.add(brok)
except Exception:
self.handleError(record)
def get_initial_status_brok(self):
"""Get a initial status brok
:return: brok with wanted data
:rtype: alignak.brok.Brok
"""
data = {'uuid': self.uuid}
self.fill_data_brok_from(data, 'full_status')
return Brok({'type': 'notification_raise', 'data': data})
def get_initial_status_brok(self):
"""Get a initial status brok
:return: brok with wanted data
:rtype: alignak.brok.Brok
"""
data = {'_id': self._id}
self.fill_data_brok_from(data, 'full_status')
brok = Brok('notification_raise', data)
return brok
def test_manage_brok_service_check_result(self):
modconf = Module()
modconf.module_name = "alignakbackend"
module = AlignakBackendBrok(modconf)
data = {
'state': 'OK',
'state_type': 'HARD',
'last_chk': 1440976938,
'output': 'TCP OK - 0.033 second response time on 93.93.47.83 port 22',
'long_output': '',
'perf_data': 'time=0.032536s;;;0.000000;3.000000',
'problem_has_been_acknowledged': False,
'service_description': 'check disk',
'host_name': 'server1'
}
brok = Brok(_type='service_check_result', data=data)
brok.prepare()
with HTTMock(server_responses):
module.manage_brok(brok)
reference = {
'55d4f7b26376e946db235fc4': {
'_id': '55d4f8746376e946db235fc8',
'_etag': 'fff582e398e47bce29e7317f25eb5068aaac3c4b'
},
'55d4f7be6376e946db235fc5': {
'_id': '55d4f8876376e946db235fc9',
'_etag': '3ed23c329f07c92fabeee465e5c4e59bc5f575f0'
},
'55d4f7cc6376e946db235fc6': {
'_id': '55d4faa26376e946db235fca',
'_etag': 'b7c4a2563f7382ed86dac2dc975759e20be778fc'
},
'55d4f7d76376e946db235fc7': {
'_id': '55d4fabd6376e946db235fcb',
'_etag': '9ab70e496605b755836be976d676be17a4bc6fea'
}
}
self.assertEqual(reference, module.ref_live['service'])
def get_expire_brok(self, host_name, service_name=''):
"""Get an expire acknowledge brok
:type item: item
:return: brok with wanted data
:rtype: alignak.brok.Brok
"""
data = self.serialize()
data['host'] = host_name
if service_name != '':
data['service'] = service_name
return Brok({'type': 'acknowledge_expire', 'data': data})
def test_manage_brok_host_check_result(self):
modconf = Module()
modconf.module_name = "alignakbackend"
module = AlignakBackendBrok(modconf)
data = {
'state': 'OK',
'state_type': 'HARD',
'last_chk': 1440976938,
'output': 'TCP OK - 0.033 second response time on 93.93.47.83 port 22',
'long_output': '',
'perf_data': 'time=0.032536s;;;0.000000;3.000000',
'problem_has_been_acknowledged': False,
'host_name': 'server1'
}
brok = Brok(_type='host_check_result', data=data)
brok.prepare()
with HTTMock(server_responses):
module.manage_brok(brok)
reference = {
'55d4a5246376e946db235fbc': {
'_etag': 'fff582e398e47bce29e7317f25eb5068aaac3c4a',
'_id': '55d4e5626376e946db235fc0'
},
'55d4a5276376e946db235fbd': {
'_etag': '3524b87876c1d457bdca7492b9bfc503f3f13b1e',
'_id': '55d4e57d6376e946db235fc1'
},
'55d4a52a6376e946db235fbe': {
'_etag': 'a457e78fe0dc28c1b427d9b0696096fee73f4a29',
'_id': '55d4e7d36376e946db235fc2'
},
'55d4a52d6376e946db235fbf': {
'_etag': '2b45425c497d5593bad8ef5413c84e6a0d61cc41',
'_id': '55d4e8126376e946db235fc3'
}
}
self.assertEqual(reference, module.ref_live['host'])
def get_raise_brok(self, host_name, service_name=''):
"""Get a start acknowledge brok
:param host_name:
:param service_name:
:return: brok with wanted data
:rtype: alignak.brok.Brok
"""
data = self.serialize()
data['host'] = host_name
if service_name != '':
data['service'] = service_name
return Brok({'type': 'acknowledge_raise', 'data': data})
def get_comment_brok(self, host_name, service_name=''):
"""Get a comment brok
:param host_name:
:param service_name:
:return: brok with wanted data
:rtype: alignak.brok.Brok
"""
data = self.serialize()
data['host'] = host_name
if service_name:
data['service'] = service_name
return Brok({'type': 'comment', 'data': data})
def get_raise_brok(self, host_name, service_name=''):
"""Get a start downtime brok
:param comment_type: 1 = host, 2 = service
:param host_name:
:param service_name:
:return: brok with wanted data
:rtype: alignak.brok.Brok
"""
data = self.serialize()
data['host'] = host_name
if service_name != '':
data['service'] = service_name
brok = Brok({'type': 'downtime_raise', 'data': data})
return brok
def make_monitoring_log(level, message):
"""
Function used to build the monitoring log. Build a Brok typed as monitoring_log with
the message to log
TODO: replace with dedicated brok for each event to log
:param level: log level as defined in logging
:param message: message to insert into the monitoring log
:return:
"""
logger.debug("Monitoring log: %s / %s", level, message)
return Brok({
'type': 'monitoring_log',
'data': {
'level': level,
'message': message
}
})
def check_service_brok(self, prop, value):
# Get an service and its full status brok
self.objects = self.arbmodule.get_objects()
my_service = None
for service in self.objects['services']:
if service['host_name'] == 'srv001' and service['service_description'] == 'ping':
my_service = Service(service)
# Get service status brok
data = {'uuid': '0123456789'}
my_service.fill_data_brok_from(data, 'full_status')
# Update brok data
if prop not in data:
print(("service property '%s' does not exit!" % prop))
return False
data[prop] = value
brok = Brok({'type': 'update_service_status', 'data': data})
brok.prepare()
print(("Before: %s" % brok))
# Send service status brok
self.brokmodule.manage_brok(brok)
# Get service data like an arbiter to check modification
self.objects = self.arbmodule.get_objects()
my_changed_service = None
for service in self.objects['services']:
if service['host_name'] == 'srv001' and service['service_description'] == 'ping':
my_changed_service = Service(service)
# Get service status brok
data = {'uuid': '0123456789'}
my_changed_service.fill_data_brok_from(data, 'full_status')
brok_bis = Brok({'type': 'update_service_status', 'data': data})
brok_bis.prepare()
print(("After: %s" % brok_bis))
# Broks data are equal, nothing changed
self.assertEqual(brok.data, brok_bis.data)
return True
def check_host_brok(self, prop, value):
# Get an host and its full status brok
self.objects = self.arbmodule.get_objects()
my_host = None
for host in self.objects['hosts']:
if host['host_name'] == 'srv001':
my_host = Host(host)
# Get host status brok
data = {'uuid': '0123456789'}
my_host.fill_data_brok_from(data, 'full_status')
# Update brok data
if prop not in data:
print(("Host property '%s' does not exit!" % prop))
return False
data[prop] = value
brok = Brok({'type': 'update_host_status', 'data': data})
brok.prepare()
print(("Brok: %s" % brok))
# Send host status brok
self.brokmodule.manage_brok(brok)
# Get host data like an arbiter to check modification
self.objects = self.arbmodule.get_objects()
my_changed_host = None
for host in self.objects['hosts']:
if host['host_name'] == 'srv001':
my_changed_host = Host(host)
# Get host status brok
data = {'uuid': '0123456789'}
my_changed_host.fill_data_brok_from(data, 'full_status')
brok_bis = Brok({'type': 'update_host_status', 'data': data})
brok_bis.prepare()
print(("Brok: %s" % brok_bis))
# Broks data are equal, nothing changed
self.assertEqual(brok.data, brok_bis.data)
return True
def check_user_brok(self, prop, value):
# Get a contact and its full status brok
self.objects = self.arbmodule.get_objects()
my_user = None
for user in self.objects['contacts']:
if user['contact_name'] == 'jeronimo':
my_user = Contact(user)
# Get user status brok
data = {'uuid': '0123456789'}
my_user.fill_data_brok_from(data, 'full_status')
# Update brok data
if prop not in data:
return False
data[prop] = value
brok = Brok({'type': 'update_contact_status', 'data': data})
brok.prepare()
print(("Brok: %s" % brok))
# Send user status brok
self.brokmodule.manage_brok(brok)
# Get user data like an arbiter to check modification
self.objects = self.arbmodule.get_objects()
my_changed_user = None
for user in self.objects['contacts']:
if user['contact_name'] == 'jeronimo':
my_changed_user = Contact(user)
# Get user status brok
data = {'uuid': '0123456789'}
my_changed_user.fill_data_brok_from(data, 'full_status')
brok_bis = Brok({'type': 'update_contact_status', 'data': data})
brok_bis.prepare()
print(("Brok: %s" % brok_bis))
# Broks data are equal, nothing changed
self.assertEqual(brok.data, brok_bis.data)
return True
def get_initial_status_brok(self):
"""
Get a brok with hostgroup info (like id, name)
Members contain list of (id, host_name)
:return:Brok object
:rtype: object
:return: None
"""
cls = self.__class__
data = {}
# Now config properties
for prop, entry in cls.properties.items():
if entry.fill_brok != []:
if hasattr(self, prop):
data[prop] = getattr(self, prop)
# Here members is just a bunch of host, I need name in place
data['members'] = []
for i in self.members:
# it look like lisp! ((( ..))), sorry....
data['members'].append((i._id, i.get_name()))
brok = Brok('initial_' + cls.my_type + '_status', data)
return brok
def setup_new_conf(self): # pylint: disable=too-many-statements
"""Setup new conf received for scheduler
:return: None
"""
with self.conf_lock:
self.clean_previous_run()
new_conf = self.new_conf
logger.info("[%s] Sending us a configuration", self.name)
conf_raw = new_conf['conf']
override_conf = new_conf['override_conf']
modules = new_conf['modules']
satellites = new_conf['satellites']
instance_name = new_conf['instance_name']
# Ok now we can save the retention data
if hasattr(self.sched, 'conf'):
self.sched.update_retention_file(forced=True)
# horay, we got a name, we can set it in our stats objects
statsmgr.register(instance_name,
'scheduler',
statsd_host=new_conf['statsd_host'],
statsd_port=new_conf['statsd_port'],
statsd_prefix=new_conf['statsd_prefix'],
statsd_enabled=new_conf['statsd_enabled'])
t00 = time.time()
try:
conf = unserialize(conf_raw)
except AlignakClassLookupException as exp: # pragma: no cover, simple protection
logger.error(
'Cannot un-serialize configuration received from arbiter: %s',
exp)
logger.debug("Conf received at %d. Un-serialized in %d secs", t00,
time.time() - t00)
self.new_conf = None
if 'scheduler_name' in new_conf:
name = new_conf['scheduler_name']
else:
name = instance_name
self.name = name
# Set my own process title
self.set_proctitle(self.name)
logger.info("[%s] Received a new configuration, containing: ",
self.name)
for key in new_conf:
logger.info("[%s] - %s", self.name, key)
logger.info("[%s] configuration identifiers: %s (%s)", self.name,
new_conf['conf_uuid'], new_conf['push_flavor'])
# Tag the conf with our data
self.conf = conf
self.conf.push_flavor = new_conf['push_flavor']
self.conf.alignak_name = new_conf['alignak_name']
self.conf.instance_name = instance_name
self.conf.skip_initial_broks = new_conf['skip_initial_broks']
self.conf.accept_passive_unknown_check_results = \
new_conf['accept_passive_unknown_check_results']
self.cur_conf = conf
self.override_conf = override_conf
self.modules = unserialize(modules, True)
self.satellites = satellites
# Now We create our pollers, reactionners and brokers
for sat_type in ['pollers', 'reactionners', 'brokers']:
if sat_type not in satellites:
continue
for sat_id in satellites[sat_type]:
# Must look if we already have it
sats = getattr(self, sat_type)
sat = satellites[sat_type][sat_id]
sats[sat_id] = sat
if sat['name'] in override_conf['satellitemap']:
sat = dict(sat) # make a copy
sat.update(override_conf['satellitemap'][sat['name']])
proto = 'http'
if sat['use_ssl']:
proto = 'https'
uri = '%s://%s:%s/' % (proto, sat['address'], sat['port'])
sats[sat_id]['uri'] = uri
sats[sat_id]['con'] = None
sats[sat_id]['running_id'] = 0
sats[sat_id]['last_connection'] = 0
sats[sat_id]['connection_attempt'] = 0
sats[sat_id]['max_failed_connections'] = 3
setattr(self, sat_type, sats)
logger.debug("We have our %s: %s ", sat_type,
satellites[sat_type])
logger.info("We have our %s:", sat_type)
for daemon in satellites[sat_type].values():
logger.info(" - %s ", daemon['name'])
# First mix conf and override_conf to have our definitive conf
for prop in self.override_conf:
val = self.override_conf[prop]
setattr(self.conf, prop, val)
if self.conf.use_timezone != '':
logger.info("Setting our timezone to %s",
str(self.conf.use_timezone))
os.environ['TZ'] = self.conf.use_timezone
time.tzset()
self.do_load_modules(self.modules)
logger.info("Loading configuration.")
self.conf.explode_global_conf() # pylint: disable=E1101
# we give sched it's conf
self.sched.reset()
self.sched.load_conf(self.conf)
self.sched.load_satellites(self.pollers, self.reactionners,
self.brokers)
# We must update our Config dict macro with good value
# from the config parameters
self.sched.conf.fill_resource_macros_names_macros()
# Creating the Macroresolver Class & unique instance
m_solver = MacroResolver()
m_solver.init(self.conf)
# self.conf.dump()
# self.conf.quick_debug()
# Now create the external commands manager
# We are an applyer: our role is not to dispatch commands, but to apply them
ecm = ExternalCommandManager(self.conf, 'applyer', self.sched)
# Scheduler needs to know about this external command manager to use it if necessary
self.sched.set_external_commands_manager(ecm)
# Update External Commands Manager
self.sched.external_commands_manager.accept_passive_unknown_check_results = \
self.sched.conf.accept_passive_unknown_check_results
# We clear our schedulers managed (it's us :) )
# and set ourselves in it
self.schedulers = {self.conf.uuid: self.sched} # pylint: disable=E1101
# Ok now we can load the retention data
self.sched.retention_load()
# Create brok new conf
brok = Brok({'type': 'new_conf', 'data': {}})
self.sched.add_brok(brok)
def test_inner_module_configuration(self):
""" Test that inner metrics module may be configured in Alignak configuration
With this configuration, hosts/services cache is enabled and tested. Broks for
unknown hosts/services are ignored.
:return: None
"""
with requests_mock.mock() as mr:
mr.get("http://localhost:8086/ping",
json={"results": [{
"statement_id": 0,
"version": "1.7.2"
}]},
status_code=204,
headers={"x-influxdb-version": "1.7.2"})
mr.get("http://localhost:8086/query?q=SHOW+DATABASES&db=alignak",
json={
"results": [{
"statement_id":
0,
"series": [{
"name": "databases",
"columns": ["name"],
"values": [["_internal"]]
}]
}]
})
mr.get("http://localhost:8086/query?q=SHOW+DATABASES&db=alignak",
json={"results": [{
"statement_id": 0
}]})
mr.post(
"http://localhost:8086/query?q=CREATE+DATABASE+%22alignak%22&db=alignak",
json={"results": [{
"statement_id": 0
}]})
mr.post(
"http://localhost:8086/query?q=CREATE+RETENTION+POLICY+%22alignak%22+ON+%22alignak%22+DURATION+1y+REPLICATION+1+SHARD+DURATION+0s&db=alignak",
json={"results": [{
"statement_id": 0
}]})
mr.post("http://localhost:8086/write?db=alignak",
status_code=204,
json={"results": [{
"statement_id": 0
}]})
self.setup_with_file('cfg/cfg_metrics.cfg',
'cfg/inner_metrics/alignak.ini')
# Specific configuration enables the module
assert self._scheduler.pushed_conf.process_performance_data is True
assert self._scheduler.pushed_conf.host_perfdata_file == 'go-hosts'
assert self._scheduler.pushed_conf.service_perfdata_file == 'go-services'
assert 1 == len(self._broker_daemon.modules)
self.show_logs()
# The declared module instance
my_module = self._broker_daemon.modules[0]
print(my_module)
# Generic stuff
assert my_module.python_name == 'alignak.modules.inner_metrics'
assert my_module.type == 'metrics'
# assert my_module.alias == 'inner-metrics'
assert my_module.enabled is True
# Specific stuff - the content of the configuration parameters
# When the module is configured in Alignak configuration, it does not exist!
# assert my_module.host_perfdata_file == 'go-hosts'
# assert my_module.service_perfdata_file == 'go-services'
assert my_module.output_file == '/tmp/alignak-metrics.log'
self.clear_logs()
# Module is not yet initialized, let's do it in place of the daemon.
# Create the modules manager for a daemon type
self.modules_manager = ModulesManager(self._broker_daemon)
# Load an initialize the modules:
# - load python module
# - get module properties and instances
self.modules_manager.load_and_init([my_module])
self.show_logs()
# self.assert_log_match(
# "Targets configuration: graphite: True, influxdb: True, "
# "file: /tmp/alignak-metrics.log", 10)
#
self.assert_log_match(
"targets configuration: graphite: True, influxdb: True, "
"file: /tmp/alignak-metrics.log", 11)
self.assert_log_match(
"Storing metrics in an output file is configured. Do not forget "
"to regularly clean this file to avoid important disk usage!",
12)
self.assert_log_match("Trying to initialize module: inner-metrics",
24)
self.assert_log_match(
"testing storage to /tmp/alignak-metrics.log ...", 25)
self.assert_log_match("Ok", 26)
self.assert_log_match(
"testing connection to InfluxDB localhost:8086 ...", 27)
self.assert_log_match("connected, InfluxDB version 1.7.2", 28)
self.assert_log_match(
"testing connection to Graphite localhost:2004 ...", 29)
self.assert_log_match("Ok", 30)
self.assert_log_match("creating database alignak...", 31)
# self.assert_log_match("creating database retention policy: alignak - 1y - 1...", 32)
# self.assert_log_match("Ok", 33)
self.assert_log_match("Module inner-metrics is initialized.", 32)
# Module is an internal one (no external process) in the broker daemon modules manager
my_module = self._broker_daemon.modules_manager.instances[0]
assert my_module.is_external is False
# Known hosts/services cache is empty
assert my_module.hosts_cache == {}
assert my_module.services_cache == {}
# File output - we still got a metric for the connection test!
assert os.path.exists('/tmp/alignak-metrics.log')
with open('/tmp/alignak-metrics.log') as f:
lines = f.readlines()
first_line = False
for line in lines:
assert 3 == len(line.split(';'))
if not first_line:
line = line.strip()
metric = line.split(';')
assert metric[0] == metric[2]
assert metric[1] == 'connection-test'
print(line)
# Some metrics were stored
assert 2 == len(lines)
# When the broker daemon receives a Brok, it is propagated to the module
# Host check result
self.clear_logs()
hcr = {
"host_name":
"srv001",
"last_time_unreachable":
0,
"last_problem_id":
0,
"passive_check":
False,
"retry_interval":
1,
"last_event_id":
0,
"problem_has_been_acknowledged":
False,
"command_name":
"pm-check_linux_host_alive",
"last_state":
"UP",
"latency":
0.2317881584,
"last_state_type":
"HARD",
"last_hard_state_change":
1444427108,
"last_time_up":
0,
"percent_state_change":
0.0,
"state":
"DOWN",
"last_chk":
1444427104,
"last_state_id":
0,
"end_time":
0,
"timeout":
0,
"current_event_id":
10,
"execution_time":
3.1496069431000002,
"start_time":
0,
"return_code":
2,
"state_type":
"SOFT",
"output":
"CRITICAL - Plugin timed out after 10 seconds",
"in_checking":
True,
"early_timeout":
0,
"in_scheduled_downtime":
False,
"attempt":
0,
"state_type_id":
1,
"acknowledgement_type":
1,
"last_state_change":
1444427108.040841,
"last_time_down":
1444427108,
"instance_id":
0,
"long_output":
"",
"current_problem_id":
0,
"check_interval":
5,
"state_id":
2,
"has_been_checked":
1,
"perf_data":
"uptime=1200;rta=0.049000ms;2.000000;3.000000;0.000000 pl=0%;50;80;0"
}
b = Brok({'data': hcr, 'type': 'host_check_result'}, False)
self._broker_daemon.manage_brok(b)
self.show_logs()
self.assert_log_count(2)
self.assert_log_match("host check result: srv001", 0)
self.assert_log_match(
"received host check result for an unknown host: srv001", 1)
# Service check result
self.clear_logs()
scr = {
"host_name": "srv001",
"service_description": "ping",
"command_name": "ping",
"attempt": 1,
"execution_time": 3.1496069431000002,
"latency": 0.2317881584,
"return_code": 2,
"state": "OK",
"state_type": "HARD",
"state_id": 0,
"state_type_id": 1,
"output": "PING OK - Packet loss = 0%, RTA = 0.05 ms",
"long_output": "Long output ...",
"perf_data":
"rta=0.049000ms;2.000000;3.000000;0.000000 pl=0%;50;80;0",
"passive_check": False,
"problem_has_been_acknowledged": False,
"acknowledgement_type": 1,
"in_scheduled_downtime": False,
"last_chk": 1473597375,
"last_state_change": 1444427108.147903,
"last_state_id": 0,
"last_state": "UNKNOWN",
"last_state_type": "HARD",
"last_hard_state_change": 0.0,
"last_time_unknown": 0,
"last_time_unreachable": 0,
"last_time_critical": 1473597376,
"last_time_warning": 0,
"last_time_ok": 0,
"retry_interval": 2,
"percent_state_change": 4.1,
"check_interval": 5,
"in_checking": False,
"early_timeout": 0,
"instance_id": "3ac88dd0c1c04b37a5d181622e93b5bc",
"current_event_id": 1,
"last_event_id": 0,
"current_problem_id": 1,
"last_problem_id": 0,
"timeout": 0,
"has_been_checked": 1,
"start_time": 0,
"end_time": 0
}
b = Brok({'data': scr, 'type': 'service_check_result'}, False)
self._broker_daemon.manage_brok(b)
self.show_logs()
self.assert_log_count(2)
self.assert_log_match("service check result: srv001/ping", 0)
self.assert_log_match(
"received service check result for an unknown host", 1)
# Initial host status
self.clear_logs()
hcr = {
"host_name": "srv001",
}
b = Brok({'data': hcr, 'type': 'initial_host_status'}, False)
self._broker_daemon.manage_brok(b)
self.show_logs()
# The module inner cache stored the host
assert 'srv001' in my_module.hosts_cache
assert my_module.hosts_cache['srv001'] == {'realm_name': 'All'}
assert my_module.services_cache == {}
# Initial service status
self.clear_logs()
hcr = {"host_name": "srv001", "service_description": "disks"}
b = Brok({'data': hcr, 'type': 'initial_service_status'}, False)
self._broker_daemon.manage_brok(b)
self.show_logs()
# The module inner cache stored the host
assert 'srv001' in my_module.hosts_cache
assert my_module.hosts_cache['srv001'] == {'realm_name': 'All'}
assert 'srv001/disks' in my_module.services_cache
assert my_module.services_cache['srv001/disks'] == {}
# Now the host srv001 is known in the module, let's raise an host brok
# Host check result
self.clear_logs()
hcr = {
"host_name":
"srv001",
"last_time_unreachable":
0,
"last_problem_id":
0,
"passive_check":
False,
"retry_interval":
1,
"last_event_id":
0,
"problem_has_been_acknowledged":
False,
"command_name":
"pm-check_linux_host_alive",
"last_state":
"UP",
"latency":
0.2317881584,
"last_state_type":
"HARD",
"last_hard_state_change":
1444427108,
"last_time_up":
0,
"percent_state_change":
0.0,
"state":
"DOWN",
"last_chk":
1444427104,
"last_state_id":
0,
"end_time":
0,
"timeout":
0,
"current_event_id":
10,
"execution_time":
3.1496069431000002,
"start_time":
0,
"return_code":
2,
"state_type":
"SOFT",
"output":
"CRITICAL - Plugin timed out after 10 seconds",
"in_checking":
True,
"early_timeout":
0,
"in_scheduled_downtime":
False,
"attempt":
0,
"state_type_id":
1,
"acknowledgement_type":
1,
"last_state_change":
1444427108.040841,
"last_time_down":
1444427108,
"instance_id":
0,
"long_output":
"",
"current_problem_id":
0,
"check_interval":
5,
"state_id":
2,
"has_been_checked":
1,
"perf_data":
"uptime=1200 rta=0.049000ms;2.000000;3.000000;0.000000 pl=0%;50;80;0"
}
b = Brok({'data': hcr, 'type': 'host_check_result'}, False)
self._broker_daemon.manage_brok(b)
self.show_logs()
self.assert_log_count(9)
self.assert_log_match("host check result: srv001", 0)
self.assert_log_match("service: host_check, metric: ", 1)
self.assert_log_match("service: host_check, metric: ", 2)
self.assert_log_match("service: host_check, metric: ", 3)
self.assert_log_match("Metrics: host_check - ", 4)
self.assert_log_match("Data: ", 5)
self.assert_log_match("Flushing 1 metrics to Graphite/carbon", 6)
self.assert_log_match("Flushing 1 metrics to InfluxDB", 7)
self.assert_log_match(
"Storing 1 metrics to /tmp/alignak-metrics.log", 8)
# Service check result
self.clear_logs()
scr = {
"host_name":
"srv001",
"service_description":
"disks",
"last_time_unreachable":
0,
"last_problem_id":
0,
"passive_check":
False,
"retry_interval":
1,
"last_event_id":
0,
"problem_has_been_acknowledged":
False,
"command_name":
"pm-check_linux_disks",
"last_state":
"UP",
"latency":
0.2317881584,
"last_state_type":
"HARD",
"last_hard_state_change":
1444427108,
"last_time_up":
0,
"percent_state_change":
0.0,
"state":
"OK",
"last_chk":
1444427104,
"last_state_id":
0,
"end_time":
0,
"timeout":
0,
"current_event_id":
10,
"execution_time":
3.1496069431000002,
"start_time":
0,
"return_code":
2,
"state_type":
"SOFT",
"output":
"DISK OK - free space: / 3326 MB (56%); / 15272 MB (77%);/boot 68 MB (69%);/home 69357 MB (27%);/var/log 819 MB (84%);",
"in_checking":
True,
"early_timeout":
0,
"in_scheduled_downtime":
False,
"attempt":
0,
"state_type_id":
1,
"acknowledgement_type":
1,
"last_state_change":
1444427108.040841,
"last_time_down":
1444427108,
"instance_id":
0,
"long_output":
"",
"current_problem_id":
0,
"check_interval":
5,
"state_id":
2,
"has_been_checked":
1,
"perf_data":
"/=2643MB;5948;5958;0;5968 /boot=68MB;88;93;0;98 /home=69357MB;253404;253409;0;253414 /var/log=818MB;970;975;0;980"
}
b = Brok({'data': scr, 'type': 'service_check_result'}, False)
self._broker_daemon.manage_brok(b)
self.show_logs()
self.assert_log_count(10)
self.assert_log_match("service check result: srv001/disks", 0)
self.assert_log_match(re.escape("service: disks, metric: "), 1)
self.assert_log_match(re.escape("service: disks, metric: "), 2)
self.assert_log_match(re.escape("service: disks, metric: "), 3)
self.assert_log_match(re.escape("service: disks, metric: "), 4)
self.assert_log_match(re.escape("Metrics: disks - "), 5)
self.assert_log_match("Data: ", 6)
self.assert_log_match("Flushing 1 metrics to Graphite/carbon", 7)
self.assert_log_match("Flushing 1 metrics to InfluxDB", 8)
self.assert_log_match(
"Storing 1 metrics to /tmp/alignak-metrics.log", 9)
# Metrics count
# File output
assert os.path.exists('/tmp/alignak-metrics.log')
with open('/tmp/alignak-metrics.log') as f:
lines = f.readlines()
first_line = False
for line in lines:
line = line.strip()
assert 3 == len(line.split(';'))
print(line)
if not first_line:
first_line = True
metric = line.split(';')
assert metric[0] == metric[2]
assert metric[1] == 'connection-test'
# Some metrics were stored!
assert 33 == len(lines)
def test_00_refused_program_status_brok(self):
"""Test with a bad formatted brok for the program status
:return: None
"""
# Get alignak endpoint resources before the brok
name = 'my_alignak'
params = {'sort': '_id', 'where': '{"name": "%s"}' % name}
all_alignak = self.backend.get_all('alignak', params)
for alignak_cfg in all_alignak['_items']:
print(("Alignak cfg: %s" % alignak_cfg))
# No alignak configuration resource
self.assertEqual(0, len(all_alignak['_items']))
# Get a BAD program status brok
brok_data = {
# Some general information
### Missing alignak_name property !
# u'alignak_name': u'my_alignak',
'instance_id': '176064a1b30741d39452415097807ab0',
'instance_name': 'scheduler-master',
# Some running information
'program_start': 1493969754,
'daemon_mode': 1,
'pid': 68989,
'last_alive': 1493970641,
'last_command_check': 1493970641,
'last_log_rotation': 1493970641,
'is_running': 1,
# Some configuration parameters
'process_performance_data': True,
'passive_service_checks_enabled': True,
'event_handlers_enabled': True,
'command_file': '',
'global_host_event_handler': None,
'interval_length': 60,
'modified_host_attributes': 0,
'check_external_commands': True,
'modified_service_attributes': 0,
'passive_host_checks_enabled': True,
'global_service_event_handler': 'None',
'notifications_enabled': True,
'check_service_freshness': True,
'check_host_freshness': True,
'flap_detection_enabled': True,
'active_service_checks_enabled': True,
'active_host_checks_enabled': True
}
brok = Brok({'type': 'update_program_status', 'data': brok_data})
brok.prepare()
# Send program status brok
self.brokmodule.manage_brok(brok)
# Get alignak endpoint resources after the brok
name = 'my_alignak'
params = {'sort': '_id', 'where': '{"name": "%s"}' % name}
all_alignak = self.backend.get_all('alignak', params)
# Still no alignak configuration resource
self.assertEqual(0, len(all_alignak['_items']))
# Get a GOOD program status brok
brok_data = {
# Some general information
'alignak_name': 'my_alignak',
'instance_id': '176064a1b30741d39452415097807ab0',
'instance_name': 'scheduler-master',
# Some running information
'program_start': 1493969754,
'daemon_mode': 1,
'pid': 68989,
'last_alive': 1493970641,
'last_command_check': 1493970641,
'last_log_rotation': 1493970641,
'is_running': 1,
# Some configuration parameters
'process_performance_data': True,
'passive_service_checks_enabled': True,
'event_handlers_enabled': True,
'command_file': '',
'global_host_event_handler': None,
'interval_length': 60,
'modified_host_attributes': 0,
'check_external_commands': True,
'modified_service_attributes': 0,
'passive_host_checks_enabled': True,
'global_service_event_handler': 'None',
'notifications_enabled': True,
'check_service_freshness': True,
'check_host_freshness': True,
'flap_detection_enabled': True,
'active_service_checks_enabled': True,
'active_host_checks_enabled': True
}
brok = Brok({'type': 'update_program_status', 'data': brok_data})
brok.prepare()
# The module has no default realm ... this should never happen !
self.brokmodule.default_realm = None
# Send program status brok
self.brokmodule.manage_brok(brok)
# Get alignak endpoint resources after the brok
name = 'my_alignak'
params = {'sort': '_id', 'where': '{"name": "%s"}' % name}
all_alignak = self.backend.get_all('alignak', params)
# Still no alignak configuration resource
self.assertEqual(0, len(all_alignak['_items']))
def test_01_program_status_brok(self):
"""Test with a brok for the program status update
:return: None
"""
# Get alignak endpoint resources before the brok
name = 'my_alignak'
params = {'sort': '_id', 'where': '{"name": "%s"}' % name}
all_alignak = self.backend.get_all('alignak', params)
for alignak_cfg in all_alignak['_items']:
print(("Alignak cfg: %s" % alignak_cfg))
# No alignak configuration resource
self.assertEqual(0, len(all_alignak['_items']))
# Get a program status brok
brok_data = {
# Some general information
'alignak_name': 'my_alignak',
'instance_id': '176064a1b30741d39452415097807ab0',
'instance_name': 'scheduler-master',
# Some running information
'program_start': 1493969754,
'daemon_mode': 1,
'pid': 68989,
'last_alive': 1493970641,
'last_command_check': 1493970641,
'last_log_rotation': 1493970641,
'is_running': 1,
# Some configuration parameters
'process_performance_data': True,
'passive_service_checks_enabled': True,
'event_handlers_enabled': True,
'command_file': '',
'global_host_event_handler': None,
'interval_length': 60,
'modified_host_attributes': 0,
'check_external_commands': True,
'modified_service_attributes': 0,
'passive_host_checks_enabled': True,
'global_service_event_handler': 'None',
'notifications_enabled': True,
'check_service_freshness': True,
'check_host_freshness': True,
'flap_detection_enabled': True,
'active_service_checks_enabled': True,
'active_host_checks_enabled': True
}
brok = Brok({'type': 'update_program_status', 'data': brok_data})
brok.prepare()
# As default, we do not manage this brok !
assert self.brokmodule.manage_update_program_status is False
# Send program status brok
self.brokmodule.manage_brok(brok)
# Get alignak endpoint resources after the brok
name = 'my_alignak'
params = {'sort': '_id', 'where': '{"name": "%s"}' % name}
all_alignak = self.backend.get_all('alignak', params)
# Still no alignak configuration resource
self.assertEqual(0, len(all_alignak['_items']))
# -------
# Now we manage this brok !
self.brokmodule.manage_update_program_status = True
# Send program status brok
self.brokmodule.manage_brok(brok)
# Get alignak endpoint resources after the brok
name = 'my_alignak'
params = {'sort': '_id', 'where': '{"name": "%s"}' % name}
all_alignak = self.backend.get_all('alignak', params)
# Now we have one resource
self.assertEqual(1, len(all_alignak['_items']))
alignak = all_alignak['_items'][0]
# Remove backend Eve fields and store creation and update timestamp
_created = alignak.pop('_created')
_updated = alignak.pop('_updated')
alignak.pop('_id')
alignak.pop('_links')
alignak.pop('_etag')
alignak.pop('schema_version')
# TODO need add this new fields in alignak brok creation
for field_name in ['use_timezone',
'illegal_macro_output_chars', 'illegal_object_name_chars',
'cleaning_queues_interval', 'max_plugins_output_length',
'enable_environment_macros', 'log_initial_states', 'log_active_checks',
'log_host_retries', 'log_service_retries', 'log_passive_checks',
'log_notifications', 'log_event_handlers', 'log_external_commands',
'log_flappings', 'log_snapshots', 'enable_notifications',
'notification_timeout', 'timeout_exit_status', 'execute_host_checks',
'max_host_check_spread', 'host_check_timeout',
'check_for_orphaned_hosts', 'execute_service_checks',
'max_service_check_spread', 'service_check_timeout',
'check_for_orphaned_services', 'flap_history', 'low_host_flap_threshold',
'high_host_flap_threshold', 'low_service_flap_threshold',
'high_service_flap_threshold', 'event_handler_timeout',
'no_event_handlers_during_downtimes', 'host_perfdata_command',
'service_perfdata_command', 'accept_passive_host_checks',
'host_freshness_check_interval', 'accept_passive_service_checks',
'service_freshness_check_interval', 'additional_freshness_latency']:
alignak.pop(field_name)
expected = brok_data.copy()
expected['name'] = expected.pop('alignak_name')
# Some fields are valued as default by the backend
expected['_sub_realm'] = True
expected['alias'] = expected['name']
expected['notes'] = ''
expected['notes_url'] = ''
expected['_realm'] = self.realm_all
expected['global_host_event_handler'] = str(expected['global_host_event_handler'])
expected['global_service_event_handler'] = 'None'
self.assertEqual(expected, alignak)
# --- 1
time.sleep(1)
# Re-send the same brok
brok_data = {
# Some general information
'alignak_name': 'my_alignak',
'instance_id': '176064a1b30741d39452415097807ab0',
'instance_name': 'scheduler-master',
# Some running information
'program_start': 1493969754,
'daemon_mode': 1,
'pid': 68989,
'last_alive': 1493970641,
'last_command_check': 1493970641,
'last_log_rotation': 1493970641,
'is_running': 1,
# Some configuration parameters
'process_performance_data': True,
'passive_service_checks_enabled': True,
'event_handlers_enabled': True,
'command_file': '',
'global_host_event_handler': None,
'interval_length': 60,
'modified_host_attributes': 0,
'check_external_commands': True,
'modified_service_attributes': 0,
'passive_host_checks_enabled': True,
'global_service_event_handler': 'None',
'notifications_enabled': True,
'check_service_freshness': True,
'check_host_freshness': True,
'flap_detection_enabled': True,
'active_service_checks_enabled': True,
'active_host_checks_enabled': True
}
brok = Brok({'type': 'update_program_status', 'data': brok_data})
brok.prepare()
self.brokmodule.manage_brok(brok)
# Get alignak endpoint resources after the brok
name = 'my_alignak'
params = {'sort': '_id', 'where': '{"name": "%s"}' % name}
all_alignak = self.backend.get_all('alignak', params)
# We still have one resource
self.assertEqual(1, len(all_alignak['_items']))
alignak = all_alignak['_items'][0]
# Remove backend Eve fields
# Creation and update timestamps did not change because there was no backend update
assert _created == alignak.pop('_created')
assert _updated == alignak.pop('_updated')
alignak.pop('_id')
alignak.pop('_links')
alignak.pop('_etag')
alignak.pop('schema_version')
# TODO need add this new fields in alignak brok creation
for field_name in ['use_timezone',
'illegal_macro_output_chars', 'illegal_object_name_chars',
'cleaning_queues_interval', 'max_plugins_output_length',
'enable_environment_macros', 'log_initial_states', 'log_active_checks',
'log_host_retries', 'log_service_retries', 'log_passive_checks',
'log_notifications', 'log_event_handlers', 'log_external_commands',
'log_flappings', 'log_snapshots', 'enable_notifications',
'notification_timeout', 'timeout_exit_status', 'execute_host_checks',
'max_host_check_spread', 'host_check_timeout',
'check_for_orphaned_hosts', 'execute_service_checks',
'max_service_check_spread', 'service_check_timeout',
'check_for_orphaned_services', 'flap_history', 'low_host_flap_threshold',
'high_host_flap_threshold', 'low_service_flap_threshold',
'high_service_flap_threshold', 'event_handler_timeout',
'no_event_handlers_during_downtimes', 'host_perfdata_command',
'service_perfdata_command', 'accept_passive_host_checks',
'host_freshness_check_interval', 'accept_passive_service_checks',
'service_freshness_check_interval', 'additional_freshness_latency']:
alignak.pop(field_name)
expected = brok_data.copy()
expected['name'] = expected.pop('alignak_name')
# Some fields are valued as default by the backend
expected['_sub_realm'] = True
expected['alias'] = expected['name']
expected['notes'] = ''
expected['notes_url'] = ''
expected['_realm'] = self.realm_all
expected['global_host_event_handler'] = str(expected['global_host_event_handler'])
expected['global_service_event_handler'] = 'None'
self.assertEqual(expected, alignak)
# --- 2
time.sleep(1)
# Update the program status
brok_data = {
# Some general information
'alignak_name': 'my_alignak',
'instance_id': '176064a1b30741d39452415097807ab0',
'instance_name': 'scheduler-master',
# Some running information
'program_start': 1493969754,
'daemon_mode': 1,
'pid': 68989,
'last_alive': 1493970641,
'last_command_check': 1493970641,
'last_log_rotation': 1493970641,
'is_running': 1,
# Some configuration parameters
'process_performance_data': True,
'passive_service_checks_enabled': True,
'event_handlers_enabled': True,
'command_file': '',
'global_host_event_handler': None,
'interval_length': 60,
'modified_host_attributes': 0,
'check_external_commands': True,
'modified_service_attributes': 0,
'passive_host_checks_enabled': True,
'global_service_event_handler': 'None',
'notifications_enabled': True,
'check_service_freshness': True,
'check_host_freshness': True,
'flap_detection_enabled': True,
'active_service_checks_enabled': True,
'active_host_checks_enabled': True
}
brok_data['flap_detection_enabled'] = False
brok = Brok({'type': 'update_program_status', 'data': brok_data})
brok.prepare()
# Send program status brok
self.brokmodule.manage_brok(brok)
# Get alignak endpoint resources after the brok
name = 'my_alignak'
params = {'sort': '_id', 'where': '{"name": "%s"}' % name}
all_alignak = self.backend.get_all('alignak', params)
# We still have one resource
self.assertEqual(1, len(all_alignak['_items']))
alignak = all_alignak['_items'][0]
# Remove backend Eve fields
# Creation timestamp did not change
assert _created == alignak['_created']
_created = alignak.pop('_created')
# But update timestamp changed !
assert _updated != alignak['_updated']
_updated = alignak.pop('_updated')
alignak.pop('_id')
alignak.pop('_links')
alignak.pop('_etag')
alignak.pop('schema_version')
# TODO need add this new fields in alignak brok creation
for field_name in ['use_timezone',
'illegal_macro_output_chars', 'illegal_object_name_chars',
'cleaning_queues_interval', 'max_plugins_output_length',
'enable_environment_macros', 'log_initial_states', 'log_active_checks',
'log_host_retries', 'log_service_retries', 'log_passive_checks',
'log_notifications', 'log_event_handlers', 'log_external_commands',
'log_flappings', 'log_snapshots', 'enable_notifications',
'notification_timeout', 'timeout_exit_status', 'execute_host_checks',
'max_host_check_spread', 'host_check_timeout',
'check_for_orphaned_hosts', 'execute_service_checks',
'max_service_check_spread', 'service_check_timeout',
'check_for_orphaned_services', 'flap_history', 'low_host_flap_threshold',
'high_host_flap_threshold', 'low_service_flap_threshold',
'high_service_flap_threshold', 'event_handler_timeout',
'no_event_handlers_during_downtimes', 'host_perfdata_command',
'service_perfdata_command', 'accept_passive_host_checks',
'host_freshness_check_interval', 'accept_passive_service_checks',
'service_freshness_check_interval', 'additional_freshness_latency']:
alignak.pop(field_name)
expected = brok_data.copy()
expected['name'] = expected.pop('alignak_name')
# Some fields are valued as default by the backend
expected['_sub_realm'] = True
expected['alias'] = expected['name']
expected['notes'] = ''
expected['notes_url'] = ''
expected['_realm'] = self.realm_all
expected['global_host_event_handler'] = str(expected['global_host_event_handler'])
expected['global_service_event_handler'] = 'None'
self.assertEqual(expected, alignak)
# --- 3
time.sleep(1)
# Re-send the same brok
brok_data = {
# Some general information
'alignak_name': 'my_alignak',
'instance_id': '176064a1b30741d39452415097807ab0',
'instance_name': 'scheduler-master',
# Some running information
'program_start': 1493969754,
'daemon_mode': 1,
'pid': 68989,
'last_alive': 1493970641,
'last_command_check': 1493970641,
'last_log_rotation': 1493970641,
'is_running': 1,
# Some configuration parameters
'process_performance_data': True,
'passive_service_checks_enabled': True,
'event_handlers_enabled': True,
'command_file': '',
'global_host_event_handler': None,
'interval_length': 60,
'modified_host_attributes': 0,
'check_external_commands': True,
'modified_service_attributes': 0,
'passive_host_checks_enabled': True,
'global_service_event_handler': 'None',
'notifications_enabled': True,
'check_service_freshness': True,
'check_host_freshness': True,
'flap_detection_enabled': True,
'active_service_checks_enabled': True,
'active_host_checks_enabled': True
}
brok_data['flap_detection_enabled'] = False
brok = Brok({'type': 'update_program_status', 'data': brok_data})
brok.prepare()
self.brokmodule.manage_brok(brok)
# Get alignak endpoint resources after the brok
name = 'my_alignak'
params = {'sort': '_id', 'where': '{"name": "%s"}' % name}
all_alignak = self.backend.get_all('alignak', params)
# We still have one resource
self.assertEqual(1, len(all_alignak['_items']))
alignak = all_alignak['_items'][0]
# Remove backend Eve fields
# Creation timestamp do not change
assert _created == alignak['_created']
_created = alignak.pop('_created')
# And update timestamp do not change!
assert _updated == alignak['_updated']
_updated = alignak.pop('_updated')
alignak.pop('_id')
alignak.pop('_links')
alignak.pop('_etag')
alignak.pop('schema_version')
# TODO need add this new fields in alignak brok creation
for field_name in ['use_timezone',
'illegal_macro_output_chars', 'illegal_object_name_chars',
'cleaning_queues_interval', 'max_plugins_output_length',
'enable_environment_macros', 'log_initial_states', 'log_active_checks',
'log_host_retries', 'log_service_retries', 'log_passive_checks',
'log_notifications', 'log_event_handlers', 'log_external_commands',
'log_flappings', 'log_snapshots', 'enable_notifications',
'notification_timeout', 'timeout_exit_status', 'execute_host_checks',
'max_host_check_spread', 'host_check_timeout',
'check_for_orphaned_hosts', 'execute_service_checks',
'max_service_check_spread', 'service_check_timeout',
'check_for_orphaned_services', 'flap_history', 'low_host_flap_threshold',
'high_host_flap_threshold', 'low_service_flap_threshold',
'high_service_flap_threshold', 'event_handler_timeout',
'no_event_handlers_during_downtimes', 'host_perfdata_command',
'service_perfdata_command', 'accept_passive_host_checks',
'host_freshness_check_interval', 'accept_passive_service_checks',
'service_freshness_check_interval', 'additional_freshness_latency']:
alignak.pop(field_name)
expected = brok_data.copy()
expected['name'] = expected.pop('alignak_name')
# Some fields are valued as default by the backend
expected['_sub_realm'] = True
expected['alias'] = expected['name']
expected['notes'] = ''
expected['notes_url'] = ''
expected['_realm'] = self.realm_all
expected['global_host_event_handler'] = str(expected['global_host_event_handler'])
expected['global_service_event_handler'] = 'None'
self.assertEqual(expected, alignak)
# --- 4
time.sleep(1)
# Update only the running properties
brok_data = {
# Some general information
'alignak_name': 'my_alignak',
'instance_id': '176064a1b30741d39452415097807ab0',
'instance_name': 'scheduler-master',
# Some running information
'program_start': 1493969754,
'daemon_mode': 1,
'pid': 68989,
'last_alive': 1493970641,
'last_command_check': 1493970641,
'last_log_rotation': 1493970641,
'is_running': 1,
# Some configuration parameters
'process_performance_data': True,
'passive_service_checks_enabled': True,
'event_handlers_enabled': True,
'command_file': '',
'global_host_event_handler': None,
'interval_length': 60,
'modified_host_attributes': 0,
'check_external_commands': True,
'modified_service_attributes': 0,
'passive_host_checks_enabled': True,
'global_service_event_handler': 'None',
'notifications_enabled': True,
'check_service_freshness': True,
'check_host_freshness': True,
'flap_detection_enabled': True,
'active_service_checks_enabled': True,
'active_host_checks_enabled': True
}
brok_data['flap_detection_enabled'] = False
brok_data['last_alive'] = 123456789
brok_data['last_command_check'] = 123456789
brok_data['last_log_rotation'] = 123456789
brok = Brok({'type': 'update_program_status', 'data': brok_data})
brok.prepare()
self.brokmodule.manage_brok(brok)
# Get alignak endpoint resources after the brok
name = 'my_alignak'
params = {'sort': '_id', 'where': '{"name": "%s"}' % name}
all_alignak = self.backend.get_all('alignak', params)
# We still have one resource
self.assertEqual(1, len(all_alignak['_items']))
alignak = all_alignak['_items'][0]
# Remove backend Eve fields
# Creation timestamp do not change
assert _created == alignak['_created']
_created = alignak.pop('_created')
# And update timestamp do not change!
assert _updated == alignak['_updated']
_updated = alignak.pop('_updated')
alignak.pop('_id')
alignak.pop('_links')
alignak.pop('_etag')
alignak.pop('schema_version')
# TODO need add this new fields in alignak brok creation
for field_name in ['use_timezone',
'illegal_macro_output_chars', 'illegal_object_name_chars',
'cleaning_queues_interval', 'max_plugins_output_length',
'enable_environment_macros', 'log_initial_states', 'log_active_checks',
'log_host_retries', 'log_service_retries', 'log_passive_checks',
'log_notifications', 'log_event_handlers', 'log_external_commands',
'log_flappings', 'log_snapshots', 'enable_notifications',
'notification_timeout', 'timeout_exit_status', 'execute_host_checks',
'max_host_check_spread', 'host_check_timeout',
'check_for_orphaned_hosts', 'execute_service_checks',
'max_service_check_spread', 'service_check_timeout',
'check_for_orphaned_services', 'flap_history', 'low_host_flap_threshold',
'high_host_flap_threshold', 'low_service_flap_threshold',
'high_service_flap_threshold', 'event_handler_timeout',
'no_event_handlers_during_downtimes', 'host_perfdata_command',
'service_perfdata_command', 'accept_passive_host_checks',
'host_freshness_check_interval', 'accept_passive_service_checks',
'service_freshness_check_interval', 'additional_freshness_latency']:
alignak.pop(field_name)
expected = brok_data.copy()
expected['name'] = expected.pop('alignak_name')
# Some fields are valued as default by the backend
expected['_sub_realm'] = True
expected['alias'] = expected['name']
expected['notes'] = ''
expected['notes_url'] = ''
expected['_realm'] = self.realm_all
expected['global_host_event_handler'] = str(expected['global_host_event_handler'])
expected['global_service_event_handler'] = 'None'
self.assertEqual(expected, alignak)
def counter(self, key, value, timestamp=None):
"""Set a counter value
If the inner key does not exist is is created
:param key: counter to update
:type key: str
:param value: counter value
:type value: float
:return: An alignak_stat brok if broks are enabled else None
"""
_min, _max, count, _sum = self.stats.get(key, (None, None, 0, 0))
count += 1
_sum += value
if _min is None or value < _min:
_min = value
if _max is None or value > _max:
_max = value
self.stats[key] = (_min, _max, count, _sum)
# Manage local statsd part
if self.statsd_enabled and self.statsd_sock:
# beware, we are sending ms here, timer is in seconds
packet = '%s.%s.%s:%d|c' % (self.statsd_prefix, self.name, key,
value)
packet = packet.encode('utf-8')
try:
self.statsd_sock.sendto(packet, self.statsd_addr)
except (socket.error, socket.gaierror):
pass
# cannot send? ok not a huge problem here and we cannot
# log because it will be far too verbose :p
# Manage Graphite part
if self.statsd_enabled and self.carbon:
self.send_to_graphite(key, value, timestamp=timestamp)
# Manage file part
if self.statsd_enabled and self.file_d:
if timestamp is None:
timestamp = int(time.time())
packet = self.line_fmt
if not self.date_fmt:
date = "%s" % timestamp
else:
date = datetime.datetime.fromtimestamp(timestamp).strftime(
self.date_fmt)
packet = packet.replace("#date#", date)
packet = packet.replace(
"#counter#", '%s.%s.%s' % (self.statsd_prefix, self.name, key))
packet = packet.replace("#value#", '%d' % value)
packet = packet.replace("#uom#", 'c')
try:
self.file_d.write(packet)
except IOError:
logger.warning("Could not write to the file: %s", packet)
if self.broks_enabled:
logger.debug("alignak stat brok: %s = %s", key, value)
if timestamp is None:
timestamp = int(time.time())
return Brok({
'type': 'alignak_stat',
'data': {
'ts': timestamp,
'type': 'counter',
'metric':
'%s.%s.%s' % (self.statsd_prefix, self.name, key),
'value': value,
'uom': 'c'
}
})
return None
def gauge(self, key, value):
"""Set a gauge value
If the inner key does not exist is is created
:param key: gauge to update
:type key: str
:param value: counter value
:type value: int
:return: An alignak_stat brok if broks are enabled else None
"""
_min, _max, count, _sum = self.stats.get(key, (None, None, 0, 0))
count += 1
_sum += value
if _min is None or value < _min:
_min = value
if _max is None or value > _max:
_max = value
self.stats[key] = (_min, _max, count, _sum)
# Manage local statsd part
if self.statsd_enabled and self.statsd_sock:
# beware, we are sending ms here, timer is in seconds
packet = '%s.%s.%s:%d|g' % (self.statsd_prefix, self.name, key,
value)
# Do not log because it is spamming the log file, but leave this code in place
# for it may be restored easily if more tests are necessary... ;)
# logger.info("Sending data: %s", packet)
try:
self.statsd_sock.sendto(packet, self.statsd_addr)
except (socket.error, socket.gaierror):
pass
# cannot send? ok not a huge problem here and we cannot
# log because it will be far too verbose :p
# Manage file part
if self.statsd_enabled and self.file_d:
packet = self.line_fmt
if not self.date_fmt:
date = "%s" % time.time()
else:
date = datetime.datetime.utcnow().strftime(self.date_fmt)
packet = packet.replace("#date#", date)
packet = packet.replace(
"#counter#", '%s.%s.%s' % (self.statsd_prefix, self.name, key))
packet = packet.replace("#value#", '%d' % value)
packet = packet.replace("#uom#", 'g')
# Do not log because it is spamming the log file, but leave this code in place
# for it may be restored easily if more tests are necessary... ;)
# logger.debug("Writing data: %s", packet)
try:
self.file_d.write(packet)
except IOError:
logger.warning("Could not write to the file: %s", packet)
if self.broks_enabled:
logger.debug("alignak stat brok: %s = %s", key, value)
return Brok({
'type': 'alignak_stat',
'data': {
'type': 'gauge',
'metric':
'%s.%s.%s' % (self.statsd_prefix, self.name, key),
'value': value,
'uom': 'g'
}
})
return None
def make_monitoring_log(level, message, timestamp=None, to_logger=False):
"""
Function used to build the monitoring log.
Emit a log message with the provided level to the monitoring log logger.
Build a Brok typed as monitoring_log with the provided message
When to_logger is True, the information is sent to the python logger, else a monitoring_log
Brok is returned. The Brok is managed by the daemons to build an Event that will br logged
by the Arbiter when it collects all the events.
TODO: replace with dedicated brok for each event to log - really useful?
:param level: log level as defined in logging
:type level: str
:param message: message to send to the monitoring log logger
:type message: str
:param to_logger: when set, send to the logger, else raise a brok
:type to_logger: bool
:param timestamp: if set, force the log event timestamp
:return: a monitoring_log Brok
:rtype: alignak.brok.Brok
"""
level = level.lower()
if level not in ['debug', 'info', 'warning', 'error', 'critical']:
return False
if to_logger:
logging.getLogger(ALIGNAK_LOGGER_NAME).debug("Monitoring log: %s / %s",
level, message)
# Emit to our monitoring log logger
message = message.replace('\r', '\\r')
message = message.replace('\n', '\\n')
logger_ = logging.getLogger(MONITORING_LOGGER_NAME)
logging_function = getattr(logger_, level)
try:
message = message.decode('utf8', 'ignore')
except UnicodeEncodeError:
pass
except AttributeError:
# Python 3 raises an exception!
pass
if timestamp:
st = datetime.datetime.fromtimestamp(timestamp).strftime(
'%Y-%m-%d %H:%M:%S')
logging_function(message, extra={'my_date': st})
else:
logging_function(message)
return True
# ... and returns a brok
return Brok({
'type': 'monitoring_log',
'data': {
'level': level,
'message': message
}
})
def test_03_manage_brok_host(self):
data = json.loads(open('cfg/brok_host_srv001_up.json').read())
b = Brok({'data': data, 'type': 'host_check_result'}, False)
b.prepare()
self.brokmodule.manage_brok(b)
params = {'where': '{"name": "srv001"}'}
r = self.backend.get('host', params)
self.assertEqual(len(r['_items']), 1)
number = 0
for index, item in enumerate(r['_items']):
self.assertEqual(item['ls_last_state'], 'UNREACHABLE')
self.assertEqual(item['ls_state'], 'UP')
self.assertEqual(item['ls_last_state_type'], 'HARD')
self.assertEqual(item['ls_state_type'], 'HARD')
self.assertEqual(item['ls_output'], 'PING OK - Packet loss = 0%, RTA = 0.05 ms')
self.assertEqual(item['ls_perf_data'],
'rta=0.049000ms;2.000000;3.000000;0.000000 pl=0%;50;80;0')
number += 1
self.assertEqual(1, number)
r = self.backend.get('service')
self.assertEqual(len(r['_items']), 2)
r = self.backend.get('livesynthesis')
self.assertEqual(len(r['_items']), 1)
self.assertEqual(r['_items'][0]['hosts_total'], 1)
self.assertEqual(r['_items'][0]['hosts_up_hard'], 1)
self.assertEqual(r['_items'][0]['hosts_up_soft'], 0)
self.assertEqual(r['_items'][0]['hosts_down_hard'], 0)
self.assertEqual(r['_items'][0]['hosts_down_soft'], 0)
self.assertEqual(r['_items'][0]['hosts_unreachable_hard'], 0)
self.assertEqual(r['_items'][0]['hosts_unreachable_soft'], 0)
self.assertEqual(r['_items'][0]['hosts_acknowledged'], 0)
self.assertEqual(r['_items'][0]['hosts_in_downtime'], 0)
self.assertEqual(r['_items'][0]['services_total'], 2)
self.assertEqual(r['_items'][0]['services_ok_hard'], 0)
self.assertEqual(r['_items'][0]['services_ok_soft'], 0)
self.assertEqual(r['_items'][0]['services_warning_hard'], 0)
self.assertEqual(r['_items'][0]['services_warning_soft'], 0)
self.assertEqual(r['_items'][0]['services_critical_hard'], 0)
self.assertEqual(r['_items'][0]['services_critical_soft'], 0)
self.assertEqual(r['_items'][0]['services_unknown_hard'], 2)
self.assertEqual(r['_items'][0]['services_unknown_soft'], 0)
self.assertEqual(r['_items'][0]['services_acknowledged'], 0)
self.assertEqual(r['_items'][0]['services_in_downtime'], 0)
# Add down host
data = json.loads(open('cfg/brok_host_srv001_down.json').read())
b = Brok({'data': data, 'type': 'host_check_result'}, False)
b.prepare()
self.brokmodule.manage_brok(b)
params = {'where': '{"name": "srv001"}'}
r = self.backend.get('host', params)
self.assertEqual(len(r['_items']), 1)
number = 0
for index, item in enumerate(r['_items']):
self.assertEqual(item['ls_last_state'], 'UP')
self.assertEqual(item['ls_state'], 'DOWN')
self.assertEqual(item['ls_last_state_type'], 'HARD')
self.assertEqual(item['ls_state_type'], 'SOFT')
self.assertEqual(item['ls_output'], 'CRITICAL - Plugin timed out after 10 seconds')
self.assertEqual(item['ls_perf_data'], '')
number += 1
self.assertEqual(1, number)
r = self.backend.get('livesynthesis')
self.assertEqual(len(r['_items']), 1)
self.assertEqual(r['_items'][0]['hosts_total'], 1)
self.assertEqual(r['_items'][0]['hosts_up_hard'], 0)
self.assertEqual(r['_items'][0]['hosts_up_soft'], 0)
self.assertEqual(r['_items'][0]['hosts_down_hard'], 0)
self.assertEqual(r['_items'][0]['hosts_down_soft'], 1)
self.assertEqual(r['_items'][0]['hosts_unreachable_hard'], 0)
self.assertEqual(r['_items'][0]['hosts_unreachable_soft'], 0)
self.assertEqual(r['_items'][0]['hosts_acknowledged'], 0)
self.assertEqual(r['_items'][0]['hosts_in_downtime'], 0)
self.assertEqual(r['_items'][0]['services_total'], 2)
self.assertEqual(r['_items'][0]['services_ok_hard'], 0)
self.assertEqual(r['_items'][0]['services_ok_soft'], 0)
self.assertEqual(r['_items'][0]['services_warning_hard'], 0)
self.assertEqual(r['_items'][0]['services_warning_soft'], 0)
self.assertEqual(r['_items'][0]['services_critical_hard'], 0)
self.assertEqual(r['_items'][0]['services_critical_soft'], 0)
self.assertEqual(r['_items'][0]['services_unknown_hard'], 2)
self.assertEqual(r['_items'][0]['services_unknown_soft'], 0)
self.assertEqual(r['_items'][0]['services_acknowledged'], 0)
self.assertEqual(r['_items'][0]['services_in_downtime'], 0)
def test_inner_module_checks_results(self):
""" Test that inner metrics module is pushing data to Graphite
:return: None
"""
self.setup_with_file('cfg/cfg_metrics.cfg')
# self.clear_logs()
# Module is an internal one (no external process) in the broker daemon modules manager
my_module = self._broker_daemon.modules_manager.instances[0]
assert my_module.is_external is False
my_module.metrics_flush_count = 1
# When the broker daemon receives a Brok, it is propagated to the module
# Host check result
self.clear_logs()
hcr = {
"host_name": "srv001",
"last_time_unreachable": 0,
"last_problem_id": 0,
"passive_check": False,
"retry_interval": 1,
"last_event_id": 0,
"problem_has_been_acknowledged": False,
"command_name": "pm-check_linux_host_alive",
"last_state": "UP",
"latency": 0.2317881584,
"last_state_type": "HARD",
"last_hard_state_change": 1444427108,
"last_time_up": 0,
"percent_state_change": 0.0,
"state": "DOWN",
"last_chk": 1444427104,
"last_state_id": 0,
"end_time": 0,
"timeout": 0,
"current_event_id": 10,
"execution_time": 3.1496069431000002,
"start_time": 0,
"return_code": 2,
"state_type": "SOFT",
"output": "CRITICAL - Plugin timed out after 10 seconds",
"in_checking": True,
"early_timeout": 0,
"in_scheduled_downtime": False,
"attempt": 0,
"state_type_id": 1,
"acknowledgement_type": 1,
"last_state_change": 1444427108.040841,
"last_time_down": 1444427108,
"instance_id": 0,
"long_output": "",
"current_problem_id": 0,
"check_interval": 5,
"state_id": 2,
"has_been_checked": 1,
"perf_data": "uptime=1200;rta=0.049000ms;2.000000;3.000000;0.000000 pl=0%;50;80;0"
}
b = Brok({'data': hcr, 'type': 'host_check_result'}, False)
self._broker_daemon.manage_brok(b)
self.show_logs()
self.assert_log_count(0)
# Service check result
self.clear_logs()
scr = {
"host_name": "srv001",
"service_description": "ping",
"command_name": "ping",
"attempt": 1,
"execution_time": 3.1496069431000002,
"latency": 0.2317881584,
"return_code": 2,
"state": "OK",
"state_type": "HARD",
"state_id": 0,
"state_type_id": 1,
"output": "PING OK - Packet loss = 0%, RTA = 0.05 ms",
"long_output": "Long output ...",
"perf_data": "rta=0.049000ms;2.000000;3.000000;0.000000 pl=0%;50;80;0",
"passive_check": False,
"problem_has_been_acknowledged": False,
"acknowledgement_type": 1,
"in_scheduled_downtime": False,
"last_chk": 1473597375,
"last_state_change": 1444427108.147903,
"last_state_id": 0,
"last_state": "UNKNOWN",
"last_state_type": "HARD",
"last_hard_state_change": 0.0,
"last_time_unknown": 0,
"last_time_unreachable": 0,
"last_time_critical": 1473597376,
"last_time_warning": 0,
"last_time_ok": 0,
"retry_interval": 2,
"percent_state_change": 4.1,
"check_interval": 5,
"in_checking": False,
"early_timeout": 0,
"instance_id": "3ac88dd0c1c04b37a5d181622e93b5bc",
"current_event_id": 1,
"last_event_id": 0,
"current_problem_id": 1,
"last_problem_id": 0,
"timeout": 0,
"has_been_checked": 1,
"start_time": 0,
"end_time": 0
}
b = Brok({'data': scr, 'type': 'service_check_result'}, False)
self._broker_daemon.manage_brok(b)
self.show_logs()
self.assert_log_count(0)
print(my_module.my_metrics)
def test_inner_module_broks(self):
""" Test that inner metrics module is managing broks with the default configuration
:return: None
"""
self.setup_with_file('cfg/cfg_metrics.cfg')
# Specific configuration enables the module
assert True == self._scheduler.pushed_conf.process_performance_data
assert self._scheduler.pushed_conf.host_perfdata_file == 'go-hosts'
assert self._scheduler.pushed_conf.service_perfdata_file == 'go-services'
assert 1 == len(self._broker_daemon.modules)
self.show_logs()
# The declared module instance
my_module = self._broker_daemon.modules[0]
# Generic stuff
assert my_module.python_name == 'alignak.modules.inner_metrics'
assert my_module.type == 'metrics'
assert my_module.alias == 'inner-metrics'
assert my_module.enabled is True
# Specific stuff - the content of the configuration parameters
assert my_module.host_perfdata_file == 'go-hosts'
assert my_module.service_perfdata_file == 'go-services'
self.clear_logs()
# Module is not yet initialized, let's do it in place of the daemon.
# Create the modules manager for a daemon type
self.modules_manager = ModulesManager(self._broker_daemon)
# Load an initialize the modules:
# - load python module
# - get module properties and instances
self.modules_manager.load_and_init([my_module])
self.show_logs()
# Module is an internal one (no external process) in the broker daemon modules manager
my_module = self._broker_daemon.modules_manager.instances[0]
assert my_module.is_external is False
# Known hosts/services cache is empty
assert my_module.hosts_cache == {}
assert my_module.services_cache == {}
# When the broker daemon receives a Brok, it is propagated to the module
# Host check result
self.clear_logs()
hcr = {
"host_name": "srv001",
"last_time_unreachable": 0,
"last_problem_id": 0,
"passive_check": False,
"retry_interval": 1,
"last_event_id": 0,
"problem_has_been_acknowledged": False,
"command_name": "pm-check_linux_host_alive",
"last_state": "UP",
"latency": 0.2317881584,
"last_state_type": "HARD",
"last_hard_state_change": 1444427108,
"last_time_up": 0,
"percent_state_change": 0.0,
"state": "DOWN",
"last_chk": 1444427104,
"last_state_id": 0,
"end_time": 0,
"timeout": 0,
"current_event_id": 10,
"execution_time": 3.1496069431000002,
"start_time": 0,
"return_code": 2,
"state_type": "SOFT",
"output": "CRITICAL - Plugin timed out after 10 seconds",
"in_checking": True,
"early_timeout": 0,
"in_scheduled_downtime": False,
"attempt": 0,
"state_type_id": 1,
"acknowledgement_type": 1,
"last_state_change": 1444427108.040841,
"last_time_down": 1444427108,
"instance_id": 0,
"long_output": "",
"current_problem_id": 0,
"check_interval": 5,
"state_id": 2,
"has_been_checked": 1,
"perf_data": "uptime=1200;rta=0.049000ms;2.000000;3.000000;0.000000 pl=0%;50;80;0"
}
b = Brok({'data': hcr, 'type': 'host_check_result'}, False)
self._broker_daemon.manage_brok(b)
self.show_logs()
self.assert_log_count(0)
# Service check result
self.clear_logs()
scr = {
"host_name": "srv001",
"service_description": "ping",
"command_name": "ping",
"attempt": 1,
"execution_time": 3.1496069431000002,
"latency": 0.2317881584,
"return_code": 2,
"state": "OK",
"state_type": "HARD",
"state_id": 0,
"state_type_id": 1,
"output": "PING OK - Packet loss = 0%, RTA = 0.05 ms",
"long_output": "Long output ...",
"perf_data": "rta=0.049000ms;2.000000;3.000000;0.000000 pl=0%;50;80;0",
"passive_check": False,
"problem_has_been_acknowledged": False,
"acknowledgement_type": 1,
"in_scheduled_downtime": False,
"last_chk": 1473597375,
"last_state_change": 1444427108.147903,
"last_state_id": 0,
"last_state": "UNKNOWN",
"last_state_type": "HARD",
"last_hard_state_change": 0.0,
"last_time_unknown": 0,
"last_time_unreachable": 0,
"last_time_critical": 1473597376,
"last_time_warning": 0,
"last_time_ok": 0,
"retry_interval": 2,
"percent_state_change": 4.1,
"check_interval": 5,
"in_checking": False,
"early_timeout": 0,
"instance_id": "3ac88dd0c1c04b37a5d181622e93b5bc",
"current_event_id": 1,
"last_event_id": 0,
"current_problem_id": 1,
"last_problem_id": 0,
"timeout": 0,
"has_been_checked": 1,
"start_time": 0,
"end_time": 0
}
b = Brok({'data': scr, 'type': 'service_check_result'}, False)
self._broker_daemon.manage_brok(b)
self.show_logs()
self.assert_log_count(0)
# Initial host status
self.clear_logs()
hcr = {
"host_name": "srv001",
}
b = Brok({'data': hcr, 'type': 'initial_host_status'}, False)
self._broker_daemon.manage_brok(b)
self.show_logs()
# The module inner cache stored the host
assert 'srv001' in my_module.hosts_cache
assert my_module.hosts_cache['srv001'] == {}
assert my_module.services_cache == {}
# Initial service status
self.clear_logs()
hcr = {
"host_name": "srv001",
"service_description": "ping"
}
b = Brok({'data': hcr, 'type': 'initial_service_status'}, False)
self._broker_daemon.manage_brok(b)
self.show_logs()
# The module inner cache stored the host
assert 'srv001' in my_module.hosts_cache
assert my_module.hosts_cache['srv001'] == {}
assert 'srv001/ping' in my_module.services_cache
assert my_module.services_cache['srv001/ping'] == {}
def setup_new_conf(self):
# pylint: disable=too-many-statements, too-many-branches, too-many-locals
"""Setup new conf received for scheduler
:return: None
"""
# Execute the base class treatment...
super(Alignak, self).setup_new_conf()
# ...then our own specific treatment!
with self.conf_lock:
# self_conf is our own configuration from the alignak environment
# self_conf = self.cur_conf['self_conf']
logger.debug("Got config: %s", self.cur_conf)
if 'conf_part' not in self.cur_conf:
self.cur_conf['conf_part'] = None
conf_part = self.cur_conf['conf_part']
# Ok now we can save the retention data
if self.sched.pushed_conf is not None:
self.sched.update_retention()
# Get the monitored objects configuration
t00 = time.time()
received_conf_part = None
try:
received_conf_part = unserialize(conf_part)
assert received_conf_part is not None
except AssertionError as exp:
# This to indicate that no configuration is managed by this scheduler...
logger.warning(
"No managed configuration received from arbiter")
except AlignakClassLookupException as exp: # pragma: no cover
# This to indicate that the new configuration is not managed...
self.new_conf = {
"_status":
"Cannot un-serialize configuration received from arbiter",
"_error": str(exp)
}
logger.error(self.new_conf)
logger.error("Back trace of the error:\n%s",
traceback.format_exc())
return
except Exception as exp: # pylint: disable=broad-except
# This to indicate that the new configuration is not managed...
self.new_conf = {
"_status":
"Cannot un-serialize configuration received from arbiter",
"_error": str(exp)
}
logger.error(self.new_conf)
self.exit_on_exception(exp, str(self.new_conf))
# if not received_conf_part:
# return
logger.info(
"Monitored configuration %s received at %d. Un-serialized in %d secs",
received_conf_part, t00,
time.time() - t00)
logger.info("Scheduler received configuration : %s",
received_conf_part)
# Now we create our pollers, reactionners and brokers
for link_type in ['pollers', 'reactionners', 'brokers']:
if link_type not in self.cur_conf['satellites']:
logger.error("Missing %s in the configuration!", link_type)
continue
my_satellites = getattr(self, link_type, {})
received_satellites = self.cur_conf['satellites'][link_type]
for link_uuid in received_satellites:
rs_conf = received_satellites[link_uuid]
logger.debug("- received %s - %s: %s",
rs_conf['instance_id'], rs_conf['type'],
rs_conf['name'])
# Must look if we already had a configuration and save our broks
already_got = rs_conf['instance_id'] in my_satellites
broks = []
actions = {}
wait_homerun = {}
external_commands = {}
running_id = 0
if already_got:
logger.warning("I already got: %s",
rs_conf['instance_id'])
# Save some information
running_id = my_satellites[link_uuid].running_id
(broks, actions,
wait_homerun, external_commands) = \
my_satellites[link_uuid].get_and_clear_context()
# Delete the former link
del my_satellites[link_uuid]
# My new satellite link...
new_link = SatelliteLink.get_a_satellite_link(
link_type[:-1], rs_conf)
my_satellites[new_link.uuid] = new_link
logger.info("I got a new %s satellite: %s", link_type[:-1],
new_link)
new_link.running_id = running_id
new_link.external_commands = external_commands
new_link.broks = broks
new_link.wait_homerun = wait_homerun
new_link.actions = actions
# Replacing the satellite address and port by those defined in satellite_map
if new_link.name in self.cur_conf['override_conf'].get(
'satellite_map', {}):
override_conf = self.cur_conf['override_conf']
overriding = override_conf.get('satellite_map')[
new_link.name]
logger.warning(
"Do not override the configuration for: %s, with: %s. "
"Please check whether this is necessary!",
new_link.name, overriding)
# First mix conf and override_conf to have our definitive conf
for prop in getattr(self.cur_conf, 'override_conf', []):
logger.debug("Overriden: %s / %s ", prop,
getattr(received_conf_part, prop, None))
logger.debug("Overriding: %s / %s ", prop,
self.cur_conf['override_conf'])
setattr(received_conf_part, prop,
self.cur_conf['override_conf'].get(prop, None))
# Scheduler modules
if not self.have_modules:
try:
logger.debug("Modules configuration: %s",
self.cur_conf['modules'])
self.modules = unserialize(self.cur_conf['modules'],
no_load=True)
except AlignakClassLookupException as exp: # pragma: no cover, simple protection
logger.error(
'Cannot un-serialize modules configuration '
'received from arbiter: %s', exp)
if self.modules:
logger.debug("I received some modules configuration: %s",
self.modules)
self.have_modules = True
self.do_load_modules(self.modules)
# and start external modules too
self.modules_manager.start_external_instances()
else:
logger.info("I do not have modules")
if received_conf_part:
logger.info("Loading configuration...")
# Propagate the global parameters to the configuration items
received_conf_part.explode_global_conf()
# We give the configuration to our scheduler
self.sched.reset()
self.sched.load_conf(self.cur_conf['instance_id'],
self.cur_conf['instance_name'],
received_conf_part)
# Once loaded, the scheduler has an inner pushed_conf object
logger.info("Loaded: %s", self.sched.pushed_conf)
# Update the scheduler ticks according to the daemon configuration
self.sched.update_recurrent_works_tick(self)
# We must update our pushed configuration macros with correct values
# from the configuration parameters
# self.sched.pushed_conf.fill_resource_macros_names_macros()
# Creating the Macroresolver Class & unique instance
m_solver = MacroResolver()
m_solver.init(received_conf_part)
# Now create the external commands manager
# We are an applyer: our role is not to dispatch commands, but to apply them
ecm = ExternalCommandManager(
received_conf_part, 'applyer', self.sched,
received_conf_part.accept_passive_unknown_check_results,
received_conf_part.log_external_commands)
# Scheduler needs to know about this external command manager to use it if necessary
self.sched.external_commands_manager = ecm
# Ok now we can load the retention data
self.sched.retention_load()
# Log hosts/services initial states
self.sched.log_initial_states()
# Create brok new conf
brok = Brok({'type': 'new_conf', 'data': {}})
self.sched.add_brok(brok)
# Initialize connection with all our satellites
logger.info("Initializing connection with my satellites:")
my_satellites = self.get_links_of_type(s_type='')
for satellite in list(my_satellites.values()):
logger.info("- : %s/%s", satellite.type, satellite.name)
if not self.daemon_connection_init(satellite):
logger.error("Satellite connection failed: %s", satellite)
if received_conf_part:
# Enable the scheduling process
logger.info("Loaded: %s", self.sched.pushed_conf)
self.sched.start_scheduling()
# Now I have a configuration!
self.have_conf = True
def test_alignak_configuration(self):
"""Test alignak configuration reading
:return:
"""
# Start broker module
modconf = Module()
modconf.module_alias = "backend_broker"
modconf.username = "******"
modconf.password = "******"
modconf.api_url = 'http://127.0.0.1:5000'
self.brokmodule = AlignakBackendBroker(modconf)
# Get a program status brok
brok_data = {
# Some general information
'alignak_name': 'my_alignak',
'instance_id': '176064a1b30741d39452415097807ab0',
'instance_name': 'scheduler-master',
# Some running information
'program_start': 1493969754,
'daemon_mode': 1,
'pid': 68989,
'last_alive': 1493970641,
'last_command_check': 1493970641,
'last_log_rotation': 1493970641,
'is_running': 1,
# Some configuration parameters
'process_performance_data': True,
'passive_service_checks_enabled': True,
'event_handlers_enabled': True,
'command_file': '',
'global_host_event_handler': None,
'interval_length': 60,
'modified_host_attributes': 0,
'check_external_commands': True,
'modified_service_attributes': 0,
'passive_host_checks_enabled': True,
'global_service_event_handler': None,
'notifications_enabled': True,
'check_service_freshness': True,
'check_host_freshness': True,
'flap_detection_enabled': True,
'active_service_checks_enabled': True,
'active_host_checks_enabled': True
}
brok = Brok({'type': 'update_program_status', 'data': brok_data})
brok.prepare()
# -------
# Configure to manage this brok (default is to ignore...) !
self.brokmodule.manage_update_program_status = True
# Send program status brok
self.brokmodule.manage_brok(brok)
# This has created an `alignak` resource...
# Now we call the Arbiter hook function to get this created configuration
# Will get all the `alignak` resources because no arbiter name is defined ...
fake_arb = Arbiter()
self.arbmodule.hook_read_configuration(fake_arb)
configuration = self.arbmodule.get_alignak_configuration()
print(("Configuration: %s" % configuration))
expected = brok_data.copy()
print(("Expected: %s" % expected))
expected['name'] = expected.pop('alignak_name')
# Some fields are valued as default by the backend
configuration.pop('_created')
configuration.pop('_updated')
configuration.pop('_id')
configuration.pop('_etag')
configuration.pop('_realm')
configuration.pop('_sub_realm')
configuration.pop('_links')
configuration.pop('schema_version')
# TODO need add this new fields in alignak brok creation
for field_name in ['use_timezone',
'illegal_macro_output_chars', 'illegal_object_name_chars',
'cleaning_queues_interval', 'max_plugins_output_length',
'enable_environment_macros', 'log_initial_states', 'log_active_checks',
'log_host_retries', 'log_service_retries', 'log_passive_checks',
'log_notifications', 'log_event_handlers', 'log_external_commands',
'log_flappings', 'log_snapshots', 'enable_notifications',
'notification_timeout', 'timeout_exit_status', 'execute_host_checks',
'max_host_check_spread', 'host_check_timeout',
'check_for_orphaned_hosts', 'execute_service_checks',
'max_service_check_spread', 'service_check_timeout',
'check_for_orphaned_services', 'flap_history', 'low_host_flap_threshold',
'high_host_flap_threshold', 'low_service_flap_threshold',
'high_service_flap_threshold', 'event_handler_timeout',
'no_event_handlers_during_downtimes', 'host_perfdata_command',
'service_perfdata_command', 'accept_passive_host_checks',
'host_freshness_check_interval', 'accept_passive_service_checks',
'service_freshness_check_interval', 'additional_freshness_latency']:
configuration.pop(field_name)
expected['alias'] = expected['name']
expected['notes'] = ''
expected['notes_url'] = ''
expected['global_host_event_handler'] = str(expected['global_host_event_handler'])
expected['global_service_event_handler'] = 'None'
self.assertEqual(configuration, expected)
# Get another program status brok
brok_data = {
# Some general information
'alignak_name': 'my_alignak_2',
'instance_id': '176064a1b30741d39452415097807ab0',
'instance_name': 'scheduler-master',
# Some running information
'program_start': 1493969754,
'daemon_mode': 1,
'pid': 68989,
'last_alive': 1493970641,
'last_command_check': 1493970641,
'last_log_rotation': 1493970641,
'is_running': 1,
# Some configuration parameters
'process_performance_data': True,
'passive_service_checks_enabled': True,
'event_handlers_enabled': True,
'command_file': '',
'global_host_event_handler': 'None',
'interval_length': 60,
'modified_host_attributes': 0,
'check_external_commands': True,
'modified_service_attributes': 0,
'passive_host_checks_enabled': True,
'global_service_event_handler': 'None',
'notifications_enabled': True,
'check_service_freshness': True,
'check_host_freshness': True,
'flap_detection_enabled': True,
'active_service_checks_enabled': True,
'active_host_checks_enabled': True
}
brok = Brok({'type': 'update_program_status', 'data': brok_data})
brok.prepare()
# Send program status brok
self.brokmodule.manage_brok(brok)
# This has created an `alignak` resource...
# Now we call the Arbiter hook function to get this created configuration
# Get the configuration for a specific arbiter / alignak
# It will be the first one created
fake_arb = Arbiter(arbiter_name='my_alignak')
self.arbmodule.hook_read_configuration(fake_arb)
configuration = self.arbmodule.get_alignak_configuration()
# Some fields are valued as default by the backend
configuration.pop('_created')
configuration.pop('_updated')
configuration.pop('_id')
configuration.pop('_etag')
configuration.pop('_realm')
configuration.pop('_sub_realm')
configuration.pop('_links')
configuration.pop('schema_version')
# TODO need add this new fields in alignak brok creation
for field_name in ['use_timezone',
'illegal_macro_output_chars', 'illegal_object_name_chars',
'cleaning_queues_interval', 'max_plugins_output_length',
'enable_environment_macros', 'log_initial_states', 'log_active_checks',
'log_host_retries', 'log_service_retries', 'log_passive_checks',
'log_notifications', 'log_event_handlers', 'log_external_commands',
'log_flappings', 'log_snapshots', 'enable_notifications',
'notification_timeout', 'timeout_exit_status', 'execute_host_checks',
'max_host_check_spread', 'host_check_timeout',
'check_for_orphaned_hosts', 'execute_service_checks',
'max_service_check_spread', 'service_check_timeout',
'check_for_orphaned_services', 'flap_history', 'low_host_flap_threshold',
'high_host_flap_threshold', 'low_service_flap_threshold',
'high_service_flap_threshold', 'event_handler_timeout',
'no_event_handlers_during_downtimes', 'host_perfdata_command',
'service_perfdata_command', 'accept_passive_host_checks',
'host_freshness_check_interval', 'accept_passive_service_checks',
'service_freshness_check_interval', 'additional_freshness_latency']:
configuration.pop(field_name)
self.assertEqual(configuration, expected)
