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)