def _send_failed(self, e, msg): """errback: remet le message en base""" errmsg = _('Requeuing message (%(reason)s).') LOGGER.info(errmsg % { "reason": get_error_message(e), }) self.queue.append(msg)
def no_database(failure): """ Méthode appelée lorsque la connexion avec la base de données ne peut être établie. """ LOGGER.error(_("Unable to contact the database: %s"), get_error_message(failure.getErrorMessage())) try: reactor.stop() except error.ReactorNotRunning: pass
def getErrorMessage(error): """ Retourne le message renvoyé par le serveur dans une exception C{txamqp.client.Closed} """ if isinstance(error, failure.Failure): error = error.value if isinstance(error, Exception): error = error.args[0] try: try: return unicode(error.fields[1]) except (UnicodeEncodeError, UnicodeDecodeError): return error.fields[1].decode('utf-8') except (KeyError, AttributeError, IndexError, UnicodeEncodeError, UnicodeDecodeError): return get_error_message(error)
def _threaded_action(self, action, servername): """ Exécute l'action sur le serveur. Cette méthode est éxecutée dans un thread séparé. @param action: Action à effectuer. Correspond à une méthode de la classe, suivie de C{Server}. @type action: C{str} @param servername: nom du serveur sur lequel lancer l'action. @type servername: C{str} """ try: getattr(self, "%sServer" % action)(servername) except ApplicationError, e: # if it fails LOGGER.error(get_error_message(e)) thread = current_thread() try: self.threads[thread]["status"] = False except KeyError: # si la clé n'est pas présente on ignore silencieusement, il # y a eu un timeout de détecté dans le thread principal. pass
def statuspublisher_factory(settings, client, providers=None): """ Construit une instance de L{StatusPublisher} @param settings: fichier de configuration @type settings: C{vigilo.common.conf.settings} @param client: client du bus @type client: L{vigilo.connector.client.VigiloClient} @param providers: liste de fournisseurs de statistiques @type providers: C{list} """ hostname = settings.get("connector", {}).get("hostname", None) if hostname is None: hostname = socket.gethostname() if "." in hostname: # on ne veut pas le FQDN hostname = hostname[:hostname.index(".")] idinstance = settings.get("instance", "") servicename = os.path.basename(sys.argv[0]) if idinstance: servicename = servicename + "-" + str(idinstance) servicename = settings.get("connector", {}).get("status_service", servicename) smne = settings["connector"].get("self_monitoring_nagios_exchange", None) smpe = settings["connector"].get("self_monitoring_perf_exchange", None) publications = settings.get('publications', {}).copy() try: # Si besoin (paramètre de surcharge défini dans la configuration) # surcharger le paramètre de publication pour les messages qui viennent # de l'auto-supervision du connecteur. if smne is not None: publications["nagios"] = smne if smpe is not None: publications["perf"] = smpe publications = parsePublications(publications) except Exception, e: LOGGER.error(_('Invalid configuration option for publications: ' '(%(error)s).') % {"error": get_error_message(e)}) sys.exit(1)
def execute(self, action, servers): """ Arrête ou démarre les applications sur les serveurs spécifiés. @param action: C{start} ou C{stop} @type action: C{str} @param servers: Liste des noms de serveurs sur lesquels exécuter l'action. @type servers: C{list} de C{str} """ if not self.applications: return status = True results = [] if isinstance(self.attempts, int) and \ self.attempts > 0: attempts = self.attempts else: attempts = 1 priorities = {} # construction d'un dictionnaire de priorité d'application # dict = {1: [app1, app2], # 2: [app3, app4]} for app in self.applications: p = app.priority if p in priorities: priorities[p].append(app) else: priorities[p] = [app] # lancement des action/application pour chaque priorité for priority in sorted(priorities, reverse=True): apps = priorities[priority] for app in apps: results.append(app.execute(action, servers, async=True)) test = 0 timedout = [] while test < attempts : test += 1 if timedout: # attente d'un interval de temps avant nouvel essai msg = _("Next attempt for %(action)s action in %(interval)d" " second(s) (attempt #%(attempt)d)") % { "action": action, "interval": self.interval, "attempt": test} LOGGER.info(msg) sleep(self.interval) for e in timedout: app = e.application act = e.action servers = e.servers # relance des exécutions précédemment en time out results.append(app.execute(act, servers, async=True)) timedout = [] for result in results: try: status = status and result.get() except ApplicationTimeOutError, e: LOGGER.info(get_error_message(e)) status = status and e.status timedout.append(e) results = [] if timedout: for e in timedout: LOGGER.error(get_error_message(e)) sys.exit(2)
def test_unknown_str_exception(self): """Message d'erreur d'une exception avec encodage inconnu.""" # "éçà" encodé en ISO-8859-15. e = ValueError('Some error \xE9\xE7\xE0') msg = get_error_message(e) self.assertTrue(isinstance(msg, unicode))
def test_utf8_str_exception(self): """Message d'erreur d'une exception UTF-8.""" # "éçà" encodé en UTF-8. e = ValueError('Some error \xC3\xA9\xC3\xA7\xC3\xA0') self.assertEquals(u'Some error éçà', get_error_message(e))
def test_unicode_exception(self): """Message d'erreur d'une exception Unicode.""" e = ValueError(u'Some error éçà') self.assertEquals(u'Some error éçà', get_error_message(e))
def load_hclasses_checks(self): """ Get all the available methods to check for a host class validity. Each host class can define in a __init__.py file three techniques to check if a host corresponds to the host class. - the first technique is an attribute named "sysdescr": a regexp which will be matched against the SNMPv2-MIB::sysDescr.0 (.1.3.6.1.2.1.1.1.0) result. Be careful to include leading and ending wildcards (.*) as needed. - the second technique is an attribute named "oid": if this OID is present in a host's SNMP walk, then the host class applies to it. - the third technique is a detect_snmp() function, for more complex matching. This function is given the whole SNMP result map, and returns True or False if the host class applies to this result. This method loads these techniques in the L{hclasschecks} hashmap for each available host class. This function is mainly used by the L{Discoverator<discoverator.Discoverator>}. """ if self.hclasschecks: return # already loaded for pathdir in self.path: if not os.path.exists(pathdir): continue for hclass in os.listdir(pathdir): if hclass.startswith("."): continue hclassdir = os.path.join(pathdir, hclass) self.hclasschecks[hclass] = { "sysdescr": None, "oid": None, "detect_snmp": None, } try: mod_info = imp.find_module(hclass, [pathdir]) except ImportError: # Pas de fichier __init__.py, __init__.pyc # ou __init__.pyo. continue try: mod = imp.load_module( "vigilo.vigiconf.tests.%s" % hclass, *mod_info) except KeyboardInterrupt: raise except Exception, e: LOGGER.warning( _("Unable to load %(file)s: %(error)s") % { 'file': hclassdir, 'error': get_error_message(e), }) else: # Mise à jour des prédicats en fonction du contenu # du fichier __init__ du module. for hccheck in self.hclasschecks[hclass].keys(): if hasattr(mod, hccheck): self.hclasschecks[hclass][hccheck] = \ getattr(mod, hccheck) finally:
def load_tests(self): """ Get all the available tests. It sets the self.tests class attributes as a dict reflecting the path to get a test. Example:: { "Test1": { "hclass1": <class Test1 from hclass1/Test1.py>, "hclass2": <class Test1 from hclass2/Test1.py>, "hclass3": <class Test1 from hclass3/Test1.py>, }, "Test2": { "hclass1": <class Test2 from hclass1/Test2.py>, "hclass4": <class Test2 from hclass4/Test2.py>, }, } """ for pathdir in self.path: if not os.path.exists(pathdir): continue for hclass in os.listdir(pathdir): if hclass.startswith("."): continue hclassdir = os.path.join(pathdir, hclass) if not os.path.isdir(hclassdir): continue # On charge d'abord la classe d'équipements. try: mod_info = imp.find_module(hclass, [pathdir]) except ImportError: LOGGER.warning( _('Invalid hostclass "%s". Missing __init__.py?') % hclass ) continue try: mod = imp.load_module( "vigilo.vigiconf.tests.%s" % hclass, *mod_info) except KeyboardInterrupt: raise except Exception, e: LOGGER.warning( _("Unable to load %(file)s: %(error)s") % { 'file': hclassdir, 'error': get_error_message(e), }) continue # Puis les tests qu'elle contient. testfiles = set() for testfile in os.listdir(hclassdir): if (not testfile.endswith((".py", ".pyc", ".pyo"))) or \ testfile.startswith("__"): continue mod_name = testfile.rpartition('.')[0] # Évite de charger plusieurs fois le même test # (depuis le .py et depuis le .pyc par exemple). if mod_name in testfiles: continue # Load the file and get the class name try: mod_info = imp.find_module(mod_name, [hclassdir]) except ImportError: # On ignore silencieusement l'erreur. continue try: mod = imp.load_module( "vigilo.vigiconf.tests.%s.%s" % (hclass, mod_name), *mod_info) except KeyboardInterrupt: raise except Exception, e: raise LOGGER.warning( _("Unable to load %(file)s: %(error)s") % { 'file': os.path.join(hclassdir, testfile), 'error': get_error_message(e), }) else: for current_test_name, current_test_class \ in inspect.getmembers(mod, self._filter_tests): if not self.tests.has_key(current_test_name): self.tests[current_test_name] = {} self.tests[current_test_name][hclass] = \ current_test_class testfiles.add(mod_name) finally: # find_module() ouvre un descripteur de fichier # en cas de succès et c'est à nous de le refermer. if mod_info[0]:
def _processException(self, failure): if not failure.check(KeyboardInterrupt): LOGGER.error(_('Unexpected error: %s'), get_error_message(failure.getErrorMessage())) return failure
def eb(f): LOGGER.error(_("Error trying to save a message to the backup " "database: %s"), get_error_message(f.value))