class Pack(Item): # pragma: no cover, this class looks no more used - see #551 """ Class to manage a Pack A Pack contain multiple configuration files (like all checks for os 'FreeBSD') """ my_type = 'pack' properties = Item.properties.copy() properties.update({'pack_name': StringProp(fill_brok=['full_status'])}) running_properties = Item.running_properties.copy() running_properties.update({'macros': StringProp(default={})}) # For debugging purpose only (nice name) def get_name(self): """ Get the name of the pack :return: the pack name string or 'UnnamedPack' :rtype: str """ try: return self.pack_name except AttributeError: return 'UnnamedPack'
class ArbiterLink(SatelliteLink): """ Class to manage the link to Arbiter daemon. With it, a master arbiter can communicate with a spare Arbiter daemon """ my_type = 'arbiter' properties = SatelliteLink.properties.copy() properties.update({ 'type': StringProp(default=u'arbiter', fill_brok=['full_status'], to_send=True), 'arbiter_name': StringProp(default='', fill_brok=['full_status']), 'host_name': StringProp(default=socket.gethostname(), to_send=True), 'port': IntegerProp(default=7770, to_send=True), 'last_master_speak': FloatProp(default=0.0) }) def is_me(self): # pragma: no cover, seems not to be used anywhere """Check if parameter name if same than name of this object TODO: is it useful? :return: true if parameter name if same than this name :rtype: bool """ logger.info( "And arbiter is launched with the hostname:%s " "from an arbiter point of view of addr:%s", self.host_name, socket.getfqdn()) return self.host_name == socket.getfqdn( ) or self.host_name == socket.gethostname() def do_not_run(self): """Check if satellite running or not If not, try to run :return: true if satellite not running :rtype: bool """ logger.debug("[%s] do_not_run", self.name) try: self.con.get('_do_not_run') return True except HTTPClientConnectionException as exp: # pragma: no cover, simple protection self.add_failed_check_attempt("Connection error when " "sending do not run: %s" % str(exp)) self.set_dead() except HTTPClientTimeoutException as exp: # pragma: no cover, simple protection self.add_failed_check_attempt("Connection timeout when " "sending do not run: %s" % str(exp)) except HTTPClientException as exp: self.add_failed_check_attempt("Error when " "sending do not run: %s" % str(exp)) return False
class Hostescalation(Item): """Hostescalation class is used to implement notification escalation for hosts TODO: Why this class does not inherit from alignak.objects.Escalation. Maybe we can merge it """ my_type = 'hostescalation' properties = Item.properties.copy() properties.update({ 'host_name': StringProp(), 'hostgroup_name': StringProp(), 'first_notification': IntegerProp(), 'last_notification': IntegerProp(), 'notification_interval': IntegerProp(default=30), # like Nagios value 'escalation_period': StringProp(default=''), 'escalation_options': ListProp(default=['d', 'u', 'r', 'w', 'c']), 'contacts': StringProp(), 'contact_groups': StringProp(), 'first_notification_time': IntegerProp(), 'last_notification_time': IntegerProp(), })
class Module(Item): """ Class to manage a module """ _id = 1 # zero is always special in database, so we do not take risk here my_type = 'module' properties = Item.properties.copy() properties.update({ 'module_alias': StringProp(), 'python_name': StringProp(), 'modules': ListProp(default=[''], split_on_coma=True), }) macros = {} # For debugging purpose only (nice name) def get_name(self): """ Get name of module :return: Name of module :rtype: str """ return self.module_alias def __repr__(self): return '<module module=%s alias=%s />' % (self.python_name, self.module_alias) __str__ = __repr__
class Businessimpactmodulation(Item): """Businessimpactmodulation class is simply a modulation of the business impact value (of a Host/Service) during a modulation period. """ my_type = 'businessimpactmodulation' properties = Item.properties.copy() properties.update({'business_impact_modulation_name': StringProp(), 'business_impact': IntegerProp(), 'modulation_period': StringProp(default=''), }) def __init__(self, params=None, parsing=True): super(Businessimpactmodulation, self).__init__(params, parsing=parsing) # Ok just put None as modulation_period, means 24x7 if not hasattr(self, 'modulation_period'): self.modulation_period = '24x7' def get_name(self): """Accessor to business_impact_modulation_name attribute :return: business impact modulation name :rtype: str """ if hasattr(self, 'business_impact_modulation_name'): return self.business_impact_modulation_name return 'Unnamed'
class BrokerLink(SatelliteLink): """ Class to manage the broker information """ my_type = 'broker' properties = SatelliteLink.properties.copy() properties.update({ 'type': StringProp(default=u'broker', fill_brok=['full_status'], to_send=True), 'broker_name': StringProp(default='', fill_brok=['full_status']), 'port': IntegerProp(default=7772, fill_brok=['full_status'], to_send=True), 'initialized': BoolProp(default=False, fill_brok=['full_status'], to_send=True), }) def prepare_for_conf(self): """Initialize the pushed configuration dictionary with the inner properties that are to be propagated to the satellite link. :return: None """ super(BrokerLink, self).prepare_for_conf() self.cfg.update({ 'satellites': { 'receivers': {}, 'pollers': {}, 'reactionners': {} } })
class PollerLink(SatelliteLink): """ Class to manage the link between Arbiter and Poller. With this, an arbiter can communicate with a poller """ my_type = 'poller' # To_send: send or not to satellite conf properties = SatelliteLink.properties.copy() properties.update({ 'type': StringProp(default=u'poller', fill_brok=['full_status'], to_send=True), 'poller_name': StringProp(default='', fill_brok=['full_status']), 'port': IntegerProp(default=7771, fill_brok=['full_status'], to_send=True), # 'min_workers': # IntegerProp(default=0, fill_brok=['full_status'], to_send=True), # 'max_workers': # IntegerProp(default=30, fill_brok=['full_status'], to_send=True), # 'processes_by_worker': # IntegerProp(default=256, fill_brok=['full_status'], to_send=True), # 'worker_polling_interval': # IntegerProp(default=1, to_send=True), 'poller_tags': ListProp(default=['None'], to_send=True), })
class Pack(Item): """ Class to manage a Pack A Pack contain multiple configuration files (like all checks for os 'FreeBSD') """ _id = 1 # zero is always special in database, so we do not take risk here my_type = 'pack' properties = Item.properties.copy() properties.update({'pack_name': StringProp(fill_brok=['full_status'])}) running_properties = Item.running_properties.copy() running_properties.update({'macros': StringProp(default={})}) # For debugging purpose only (nice name) def get_name(self): """ Get the name of the pack :return: the pack name string or 'UnnamedPack' :rtype: str """ try: return self.pack_name except AttributeError: return 'UnnamedPack'
class Comment(AlignakObject): """Comment class implements comments for monitoring purpose. It contains data like author, type etc.. """ my_type = 'comment' properties = { 'entry_time': IntegerProp(), 'author': StringProp(default='(Alignak)'), 'comment': StringProp(default='Automatic Comment'), 'comment_type': IntegerProp(), 'entry_type': IntegerProp(), 'source': IntegerProp(), 'expires': BoolProp(), 'ref': StringProp(default=''), } def __init__(self, params, parsing=True): """Adds a comment to a particular service. :param ref: reference object (host / service) :type ref: alignak.object.schedulingitem.SchedulingItem :param author: Author of this comment :type author: str :param comment: text comment itself :type comment: str :param comment_type: comment type :: * 1 <=> HOST_COMMENT * 2 <=> SERVICE_COMMENT :type comment_type: int :param entry_type: type of entry linked to this comment :: * 1 <=> USER_COMMENT * 2 <=>DOWNTIME_COMMENT * 3 <=>FLAPPING_COMMENT * 4 <=>ACKNOWLEDGEMENT_COMMENT :type entry_type: int :param source: source of this comment :: * 0 <=> COMMENTSOURCE_INTERNAL * 1 <=> COMMENTSOURCE_EXTERNAL :type source: int :param expires: comment expires or not :type expires: bool :return: None """ super(Comment, self).__init__(params, parsing) if not hasattr(self, 'entry_time'): self.entry_time = int(time.time()) self.fill_default() def __str__(self): return "Comment id=%s %s" % (self.uuid, self.comment)
class SchedulerLink(SatelliteLink): """ Class to manage the scheduler information """ _id = 0 # Ok we lie a little here because we are a mere link in fact my_type = 'scheduler' properties = SatelliteLink.properties.copy() properties.update({ 'scheduler_name': StringProp(fill_brok=['full_status']), 'port': IntegerProp(default=7768, fill_brok=['full_status']), 'weight': IntegerProp(default=1, fill_brok=['full_status']), 'skip_initial_broks': BoolProp(default=False, fill_brok=['full_status']), 'accept_passive_unknown_check_results': BoolProp(default=False, fill_brok=['full_status']), }) running_properties = SatelliteLink.running_properties.copy() running_properties.update({ 'conf': StringProp(default=None), 'need_conf': StringProp(default=True), 'external_commands': StringProp(default=[]), 'push_flavor': IntegerProp(default=0), }) def run_external_commands(self, commands): """ Run external commands :param commands: :type commands: :return: False, None :rtype: bool | None TODO: need recode this fonction because return types are too many """ if self.con is None: self.create_connection() if not self.alive: return None logger.debug("[SchedulerLink] Sending %d commands", len(commands)) try: self.con.post('run_external_commands', {'cmds': commands}) except HTTPEXCEPTIONS, exp: self.con = None logger.debug(exp) return False
class SchedulerLink(SatelliteLink): """ Class to manage the scheduler information """ # Ok we lie a little here because we are a mere link in fact my_type = 'scheduler' properties = SatelliteLink.properties.copy() properties.update({ 'type': StringProp(default=u'scheduler', fill_brok=['full_status'], to_send=True), 'scheduler_name': StringProp(default='', fill_brok=['full_status']), 'port': IntegerProp(default=7768, fill_brok=['full_status'], to_send=True), 'weight': IntegerProp(default=1, fill_brok=['full_status']), 'skip_initial_broks': BoolProp(default=False, fill_brok=['full_status'], to_send=True), 'accept_passive_unknown_check_results': BoolProp(default=False, fill_brok=['full_status'], to_send=True), }) running_properties = SatelliteLink.running_properties.copy() running_properties.update({ # 'conf': # StringProp(default=None), # 'cfg': # DictProp(default={}), 'need_conf': StringProp(default=True), 'external_commands': StringProp(default=[]), }) def get_override_configuration(self): """ Some parameters can give as 'overridden parameters' like use_timezone so they will be mixed (in the scheduler) with the standard conf sent by the arbiter :return: dictionary of properties :rtype: dict """ res = {} properties = self.__class__.properties for prop, entry in list(properties.items()): if entry.override: res[prop] = getattr(self, prop) return res
class Module(Item): """ Class to manage a module """ my_type = 'module' properties = Item.properties.copy() properties.update({ 'python_name': StringProp(), 'module_alias': StringProp(), 'module_types': ListProp(default=[''], split_on_coma=True), 'modules': ListProp(default=[''], split_on_coma=True) }) macros = {} # For debugging purpose only (nice name) def get_name(self): """ Get name of module :return: Name of module :rtype: str """ return self.module_alias def get_types(self): """ Get name of module :return: Name of module :rtype: str """ return self.module_types def is_a_module(self, module_type): """ Is the module of the required type? :param module_type: module type to check :type: str :return: True / False """ return module_type in self.module_types def __repr__(self): return '<module module=%s alias=%s />' % (self.python_name, self.module_alias) __str__ = __repr__
class ReceiverLink(SatelliteLink): """ Class to manage the receiver information """ my_type = 'receiver' properties = SatelliteLink.properties.copy() properties.update({ 'type': StringProp(default='receiver', fill_brok=['full_status'], to_send=True), 'receiver_name': StringProp(default='', fill_brok=['full_status'], to_send=True), 'port': IntegerProp(default=7772, fill_brok=['full_status'], to_send=True), })
class Poller(Satellite): """Poller class. Referenced as "app" in most Interface """ do_checks = True # I do checks do_actions = False # but no actions my_type = 'poller' properties = Satellite.properties.copy() properties.update({ 'daemon_type': StringProp(default='poller'), 'pidfile': PathProp(default='pollerd.pid'), 'port': IntegerProp(default=7771), 'local_log': PathProp(default='pollerd.log'), }) def __init__(self, config_file, is_daemon, do_replace, debug, debug_file, port=None, local_log=None, daemon_name=None): self.daemon_name = 'poller' if daemon_name: self.daemon_name = daemon_name super(Poller, self).__init__(self.daemon_name, config_file, is_daemon, do_replace, debug, debug_file, port, local_log)
class EventHandler(Action): """Notification class, inherits from action class. Used to execute action when a host or a service is in a bad state """ # AutoSlots create the __slots__ with properties and # running_properties names __metaclass__ = AutoSlots my_type = 'eventhandler' properties = Action.properties.copy() properties.update({ 'is_a': StringProp(default=u'eventhandler'), 'is_snapshot': BoolProp(default=False), }) def __init__(self, params=None, parsing=False): super(EventHandler, self).__init__(params, parsing=parsing) self.fill_default() # An event handler mus be launched as soon as possible self.t_to_go = time.time() def __str__(self): # pragma: no cover return "Event Handler %s, item: %s, status: %s command: %s" \ % (self.uuid, self.ref, self.status, self.command) def get_return_from(self, e_handler): """Setter of the following attributes:: * exit_status * output * long_output * check_time * execution_time * perf_data :param e_handler: event handler to get data from :type e_handler: alignak.eventhandler.EventHandler :return: None """ for prop in [ 'exit_status', 'output', 'long_output', 'check_time', 'execution_time', 'perf_data' ]: setattr(self, prop, getattr(e_handler, prop)) def get_outputs(self, out, max_plugins_output_length): """Setter of output attribute :param out: new output :type out: str :param max_plugins_output_length: not used :type max_plugins_output_length: int :return: None """ self.output = out
class Reactionner(Satellite): """ This class is an application that launches actions for the schedulers Actions can be: Notifications Event handlers When running the Reactionner will : Respond to pings from Arbiter Listen for new configurations from Arbiter The configuration consists of a list of Schedulers for which the Reactionner will launch actions for. """ do_checks = False # I do not do checks do_actions = True my_type = 'reactionner' properties = Satellite.properties.copy() properties.update({ 'type': StringProp(default='reactionner'), 'port': IntegerProp(default=7769) }) def __init__(self, **kwargs): """Reactionner daemon initialisation :param kwargs: command line arguments """ super(Reactionner, self).__init__(kwargs.get('daemon_name', 'Default-reactionner'), **kwargs)
class ReactionnerLink(SatelliteLink): """ Class to manage the reactionner information """ my_type = 'reactionner' properties = SatelliteLink.properties.copy() properties.update({ 'reactionner_name': StringProp(fill_brok=['full_status'], to_send=True), 'port': IntegerProp(default=7769, fill_brok=['full_status']), 'min_workers': IntegerProp(default=1, fill_brok=['full_status'], to_send=True), 'max_workers': IntegerProp(default=30, fill_brok=['full_status'], to_send=True), 'processes_by_worker': IntegerProp(default=256, fill_brok=['full_status'], to_send=True), 'reactionner_tags': ListProp(default=['None'], to_send=True), }) def register_to_my_realm( self): # pragma: no cover, seems not to be used anywhere """ Add this reactionner to the realm :return: None """ self.realm.reactionners.append(self)
class PollerLink(SatelliteLink): """ Class to manage the link between Arbiter and Poller. With it, arbiter can see if a poller is alive, and can send it new configuration """ my_type = 'poller' # To_send: send or not to satellite conf properties = SatelliteLink.properties.copy() properties.update({ 'poller_name': StringProp(fill_brok=['full_status'], to_send=True), 'port': IntegerProp(default=7771, fill_brok=['full_status']), 'min_workers': IntegerProp(default=0, fill_brok=['full_status'], to_send=True), 'max_workers': IntegerProp(default=30, fill_brok=['full_status'], to_send=True), 'processes_by_worker': IntegerProp(default=256, fill_brok=['full_status'], to_send=True), 'poller_tags': ListProp(default=['None'], to_send=True), }) def register_to_my_realm( self): # pragma: no cover, seems not to be used anywhere """ Add this relation to the realm :return: None """ self.realm.pollers.append(self)
class ReceiverLink(SatelliteLink): """ Class to manage the receiver information """ _id = 0 my_type = 'receiver' properties = SatelliteLink.properties.copy() properties.update({ 'receiver_name': StringProp(fill_brok=['full_status'], to_send=True), 'port': IntegerProp(default=7772, fill_brok=['full_status']), 'manage_sub_realms': BoolProp(default=True, fill_brok=['full_status']), 'manage_arbiters': BoolProp(default=False, fill_brok=['full_status'], to_send=True), 'direct_routing': BoolProp(default=False, fill_brok=['full_status'], to_send=True), 'accept_passive_unknown_check_results': BoolProp(default=False, fill_brok=['full_status'], to_send=True), }) def register_to_my_realm(self): """ Add this reactionner to the realm :return: None """ self.realm.receivers.append(self) def push_host_names(self, sched_id, hnames): """ Send host names to receiver :param sched_id: id of the scheduler :type sched_id: int :param hnames: list of host names :type hnames: list :return: None """ try: if self.con is None: self.create_connection() logger.info(" (%s)", self.uri) # If the connection failed to initialize, bail out if self.con is None: self.add_failed_check_attempt() return # r = self.con.push_host_names(sched_id, hnames) self.con.get('ping') self.con.post('push_host_names', { 'sched_id': sched_id, 'hnames': hnames }, wait='long') except HTTPEXCEPTIONS, exp: self.add_failed_check_attempt(reason=str(exp))
class Resultmodulation(Item): """Resultmodulation class is simply a modulation of a check result exit code during a modulation_period. """ _id = 1 # zero is always special in database, so we do not take risk here my_type = 'resultmodulation' properties = Item.properties.copy() properties.update({ 'resultmodulation_name': StringProp(), 'exit_codes_match': IntListProp(default=[]), 'exit_code_modulation': IntegerProp(default=None), 'modulation_period': StringProp(default=None), }) def get_name(self): """Accessor to resultmodulation_name attribute :return: result modulation name :rtype: str """ return self.resultmodulation_name def module_return(self, return_code): """Module the exit code if necessary :: * modulation_period is legit * exit_code_modulation * return_code in exit_codes_match :param return_code: actual code returned by the check :type return_code: int :return: return_code modulated if necessary (exit_code_modulation) :rtype: int """ # Only if in modulation_period of modulation_period == None if self.modulation_period is None or self.modulation_period.is_time_valid( time.time()): # Try to change the exit code only if a new one is defined if self.exit_code_modulation is not None: # First with the exit_code_match if return_code in self.exit_codes_match: return_code = self.exit_code_modulation return return_code
class Hostdependency(Item): """Hostdependency class is a simple implementation of host dependency as defined in a monitoring context (dependency period, notification_failure_criteria ..) """ _id = 0 my_type = 'hostdependency' # F is dep of D # host_name Host B # service_description Service D # dependent_host_name Host C # dependent_service_description Service F # execution_failure_criteria o # notification_failure_criteria w,u # inherits_parent 1 # dependency_period 24x7 properties = Item.properties.copy() properties.update({ 'dependent_host_name': StringProp(), 'dependent_hostgroup_name': StringProp(default=''), 'host_name': StringProp(), 'hostgroup_name': StringProp(default=''), 'inherits_parent': BoolProp(default=False), 'execution_failure_criteria': ListProp(default=['n'], split_on_coma=True), 'notification_failure_criteria': ListProp(default=['n'], split_on_coma=True), 'dependency_period': StringProp(default='') }) def get_name(self): """Get name based on dependent_host_name and host_name attributes Each attribute is substituted by 'unknown' if attribute does not exist :return: dependent_host_name/host_name :rtype: str """ dependent_host_name = 'unknown' if getattr(self, 'dependent_host_name', None): dependent_host_name = getattr( getattr(self, 'dependent_host_name'), 'host_name', 'unknown' ) host_name = 'unknown' if getattr(self, 'host_name', None): host_name = getattr(getattr(self, 'host_name'), 'host_name', 'unknown') return dependent_host_name + '/' + host_name
class Serviceescalation(Item): """Serviceescalation class is used to implement notification escalation for services TODO: Why this class does not inherit from alignak.objects.Escalation. Maybe we can merge it """ my_type = 'serviceescalation' properties = Item.properties.copy() properties.update({ 'host_name': StringProp(), 'hostgroup_name': StringProp(), 'service_description': StringProp(), 'first_notification': IntegerProp(), 'last_notification': IntegerProp(), 'notification_interval': IntegerProp(default=30), # like Nagios value 'escalation_period': StringProp(default=''), 'escalation_options': ListProp(default=['w', 'x', 'c', 'r'], split_on_comma=True), 'contacts': ListProp(default=[], merging='join', split_on_comma=True), 'contact_groups': ListProp(default=[], merging='join', split_on_comma=True), 'first_notification_time': IntegerProp(), 'last_notification_time': IntegerProp(), }) def __init__(self, params=None, parsing=True): if params is None: params = {} for prop in ['escalation_options']: if prop in params: params[prop] = [p.replace('u', 'x') for p in params[prop]] super(Serviceescalation, self).__init__(params, parsing=parsing)
class Hostescalation(Item): """Hostescalation class is used to implement notification escalation for hosts TODO: Why this class does not inherit from alignak.objects.Escalation. Maybe we can merge it """ _id = 1 # zero is always special in database, so we do not take risk here my_type = 'hostescalation' properties = Item.properties.copy() properties.update({ 'host_name': StringProp(), 'hostgroup_name': StringProp(), 'first_notification': IntegerProp(), 'last_notification': IntegerProp(), 'notification_interval': IntegerProp(default=30), # like Nagios value 'escalation_period': StringProp(default=''), 'escalation_options': ListProp(default=['d', 'u', 'r', 'w', 'c']), 'contacts': StringProp(), 'contact_groups': StringProp(), 'first_notification_time': IntegerProp(), 'last_notification_time': IntegerProp(), }) def get_name(self): """Get escalation name :return: name :rtype: str TODO: Remove this function """ return ''
class Businessimpactmodulation(Item): """Businessimpactmodulation class is simply a modulation of the business impact value (of a Host/Service) during a modulation period. """ _id = 1 # zero is always special in database, so we do not take risk here my_type = 'businessimpactmodulation' properties = Item.properties.copy() properties.update({ 'business_impact_modulation_name': StringProp(), 'business_impact': IntegerProp(), 'modulation_period': StringProp(default=''), }) def get_name(self): """Accessor to business_impact_modulation_name attribute :return: business impact modulation name :rtype: str """ return self.business_impact_modulation_name
class Servicedependency(Item): """Servicedependency class is a simple implementation of service dependency as defined in a monitoring context (dependency period, notification_failure_criteria ..) """ my_type = "servicedependency" # F is dep of D # host_name Host B # service_description Service D # dependent_host_name Host C # dependent_service_description Service F # execution_failure_criteria o # notification_failure_criteria w,u # inherits_parent 1 # dependency_period 24x7 properties = Item.properties.copy() properties.update({ 'dependent_host_name': StringProp(), 'dependent_hostgroup_name': StringProp(default=''), 'dependent_service_description': StringProp(), 'host_name': StringProp(), 'hostgroup_name': StringProp(default=''), 'service_description': StringProp(), 'inherits_parent': BoolProp(default=False), 'execution_failure_criteria': ListProp(default=['n'], split_on_comma=True), 'notification_failure_criteria': ListProp(default=['n'], split_on_comma=True), 'dependency_period': StringProp(default=''), 'explode_hostgroup': BoolProp(default=False) }) def get_name(self): """Get name based on 4 class attributes Each attribute is substituted by '' if attribute does not exist :return: dependent_host_name/dependent_service_description..host_name/service_description :rtype: str TODO: Clean this function (use format for string) """ return getattr(self, 'dependent_host_name', '') + '/'\ + getattr(self, 'dependent_service_description', '') \ + '..' + getattr(self, 'host_name', '') + '/' \ + getattr(self, 'service_description', '')
class HostExtInfo(GenericExtInfo): """HostExtInfo class is made to handle some parameters of SchedulingItem:: * notes * notes_url * icon_image * icon_image_alt TODO: Is this class really necessary? """ # AutoSlots create the __slots__ with properties and # running_properties names __metaclass__ = AutoSlots my_type = 'hostextinfo' properties = Item.properties.copy() properties.update({ 'host_name': StringProp(), 'notes': StringProp(default=u''), 'notes_url': StringProp(default=u''), 'icon_image': StringProp(default=u''), 'icon_image_alt': StringProp(default=u''), 'vrml_image': StringProp(default=u''), 'statusmap_image': StringProp(default=u''), # No slots for this 2 because begin property by a number seems bad # it's stupid! '2d_coords': StringProp(default=u'', no_slots=True), '3d_coords': StringProp(default=u'', no_slots=True), }) # Hosts macros and prop that give the information # the prop can be callable or not macros = { 'HOSTNAME': 'host_name', 'HOSTNOTESURL': 'notes_url', 'HOSTNOTES': 'notes', }
class Reactionner(Satellite): """ This class is an application that launches actions for the schedulers Actions can be: Notifications Event handlers When running the Reactionner will : Respond to pings from Arbiter Listen for new configurations from Arbiter The configuration consists of a list of Schedulers for which the Reactionner will launch actions for. """ do_checks = False # I do not do checks do_actions = True my_type = 'reactionner' properties = Satellite.properties.copy() properties.update({ 'daemon_type': StringProp(default='reactionner'), 'pidfile': PathProp(default='reactionnerd.pid'), 'port': IntegerProp(default=7769), 'local_log': PathProp(default='reactionnerd.log'), }) def __init__(self, config_file, is_daemon, do_replace, debug, debug_file, port=None, local_log=None, daemon_name=None): self.daemon_name = 'reactionner' if daemon_name: self.daemon_name = daemon_name super(Reactionner, self).__init__(self.daemon_name, config_file, is_daemon, do_replace, debug, debug_file, port, local_log)
class BrokerLink(SatelliteLink): """ Class to manage the broker information """ my_type = 'broker' properties = SatelliteLink.properties.copy() properties.update({ 'broker_name': StringProp(fill_brok=['full_status'], to_send=True), 'port': IntegerProp(default=7772, fill_brok=['full_status']), }) def register_to_my_realm( self): # pragma: no cover, seems not to be used anywhere """ Add this broker to the realm :return: None """ self.realm.brokers.append(self)
class ServiceExtInfo(GenericExtInfo): """ServiceExtInfo class is made to handle some parameters of SchedulingItem:: * notes * notes_url * icon_image * icon_image_alt TODO: Is this class really necessary? """ # AutoSlots create the __slots__ with properties and # running_properties names __metaclass__ = AutoSlots my_type = 'serviceextinfo' # properties defined by configuration # *required: is required in conf # *default: default value if no set in conf # *pythonize: function to call when transforming string to python object # *fill_brok: if set, send to broker. there are two categories: # full_status for initial and update status, check_result for check results # *no_slots: do not take this property for __slots__ # Only for the initial call # conf_send_preparation: if set, will pass the property to this function. It's used to "flatten" # some dangerous properties like realms that are too 'linked' to be send like that. # brok_transformation: if set, will call the function with the value of the property # the major times it will be to flatten the data (like realm_name instead of the realm object). properties = Item.properties.copy() properties.update({ 'host_name': StringProp(), 'service_description': StringProp(), 'notes': StringProp(default=''), 'notes_url': StringProp(default=''), 'icon_image': StringProp(default=''), 'icon_image_alt': StringProp(default=''), }) # Hosts macros and prop that give the information # the prop can be callable or not macros = { 'SERVICEDESC': 'service_description', 'SERVICEACTIONURL': 'action_url', 'SERVICENOTESURL': 'notes_url', 'SERVICENOTES': 'notes' }
class Poller(Satellite): """Poller class. Referenced as "app" in most Interface """ do_checks = True # I do checks do_actions = False # but no actions my_type = 'poller' properties = Satellite.properties.copy() properties.update({ 'type': StringProp(default='poller'), 'port': IntegerProp(default=7771) }) def __init__(self, **kwargs): """Poller daemon initialisation :param kwargs: command line arguments """ super(Poller, self).__init__(kwargs.get('daemon_name', 'Default-poller'), **kwargs)