def get_data(self, event):
state = StateName.value_to_statename(event[0].cause.current_state)
peak_state = StateName.value_to_statename(event[0].cause.peak_state)
init_state = StateName.value_to_statename(event[0].cause.initial_state)
return {
'state': state,
'peak_state': peak_state,
'initial_state': init_state,
'id': event[0].idcorrevent,
}
def test_insert_lls_event(self):
"""Insertion d'un évènement brut concernant un SBN"""
self.make_dependencies()
# Création d'un message d'événement portant sur un SBN.
info_dictionary = {
"type": "event",
"timestamp": datetime.fromtimestamp(1239104006),
"host": "server.example.com",
"service": "Load",
"state": u"WARNING",
"message": u"WARNING: Load average is above 4 (4.5)",
}
info_dictionary['idsupitem'] = SupItem.get_supitem(
info_dictionary['host'],
info_dictionary['service']
)
# Insertion de l'événement dans la BDD
idevent = insert_event(info_dictionary)
assert idevent is not None
event = DBSession.query(Event).one()
# Vérification des informations de l'événement dans la BDD.
self.assertEquals(LowLevelService, type(event.supitem))
self.assertEquals(1239104006, time.mktime(event.timestamp.timetuple()))
self.assertEquals(u'server.example.com', event.supitem.host.name)
self.assertEquals(u'Load', event.supitem.servicename)
self.assertEquals(u'WARNING',
StateName.value_to_statename(event.current_state))
self.assertEquals(u'WARNING',
StateName.value_to_statename(event.initial_state))
self.assertEquals(u'WARNING',
StateName.value_to_statename(event.peak_state))
self.assertEquals(u'WARNING: Load average is above 4 (4.5)',
event.message)
# Insertion de l'état dans la BDD
state = DBSession.query(State).get(info_dictionary['idsupitem'])
# le timestamp par défaut est plus récent et insert_state refusera la
# mise à jour
state.timestamp = info_dictionary['timestamp']
insert_state(info_dictionary)
# Vérification des informations de l'état dans la BDD.
self.assertEquals(LowLevelService, type(state.supitem))
self.assertEquals(1239104006, time.mktime(state.timestamp.timetuple()))
self.assertEquals('server.example.com', state.supitem.host.name)
self.assertEquals('Load', state.supitem.servicename)
self.assertEquals('WARNING',
StateName.value_to_statename(state.state))
self.assertEquals('WARNING: Load average is above 4 (4.5)',
state.message)
def test_insert_host_event(self):
"""Insertion d'un évènement brut concernant un hôte"""
self.make_dependencies()
# Création d'un message d'événement portant sur un hôte.
info_dictionary = {
"type": "event",
"timestamp": datetime.fromtimestamp(1239104006),
"host": "server.example.com",
"state": u"DOWN",
"message": u"DOWN: No ping response",
}
info_dictionary['idsupitem'] = SupItem.get_supitem(
info_dictionary['host'], None,
)
# Insertion de l'événement dans la BDD
idevent = insert_event(info_dictionary)
assert idevent is not None
event = DBSession.query(Event).one()
# Vérification des informations de l'événement dans la BDD.
self.assertEquals(Host, type(event.supitem))
self.assertEquals(1239104006, time.mktime(event.timestamp.timetuple()))
self.assertEquals(u'server.example.com', event.supitem.name)
self.assertEquals(u'DOWN',
StateName.value_to_statename(event.current_state))
self.assertEquals(u'DOWN',
StateName.value_to_statename(event.initial_state))
self.assertEquals(u'DOWN',
StateName.value_to_statename(event.peak_state))
self.assertEquals(u'DOWN: No ping response',
event.message)
# Insertion de l'état dans la BDD
state = DBSession.query(State).get(info_dictionary['idsupitem'])
# le timestamp par défaut est plus récent et insert_state refusera la
# mise à jour
state.timestamp = info_dictionary['timestamp']
insert_state(info_dictionary)
# Vérification des informations de l'état dans la BDD.
self.assertEquals(Host, type(state.supitem))
self.assertEquals(1239104006, time.mktime(state.timestamp.timetuple()))
self.assertEquals('server.example.com', state.supitem.name)
self.assertEquals('DOWN',
StateName.value_to_statename(state.state))
self.assertEquals('DOWN: No ping response', state.message)
def process(self, link, msg_id):
"""
Traitement du message par la règle.
@param link: Objet servant de lien avec le dispatcher et pouvant
par exemple être utilisé pour envoyer des messages sur le bus.
@type link: C{vigilo.correlator.actors.rule_runner.RuleRunner}
@param msg_id: Identifiant de l'alerte brute traitée.
@type msg_id: C{unicode}
"""
ctx = self._get_context(msg_id)
hostname = ctx.get('hostname')
servicename = ctx.get('servicename')
if servicename or not hostname:
return # On ne traite que les évènements sur les hôtes
statename = ctx.get('statename')
previous_state = ctx.get('previous_state')
if previous_state is None:
previous_statename = "UP" # inconnu = UP
else:
previous_statename = StateName.value_to_statename(previous_state)
if statename == previous_statename:
return # Pas de changement
if previous_statename == "UP" and statename in ("DOWN", "UNREACHABLE"):
link.registerCallback(fn=on_host_down, idnt=msg_id)
elif previous_statename in ("DOWN", "UNREACHABLE") and statename == "UP":
self._on_host_up(hostname, link)
else:
LOGGER.info(_("Unsupported transition: %(from)s -> %(to)s"),
{"from": previous_statename, "to": statename})
def get_data(self, event):
cause = event[0].cause
ack = event[0].ack
state = StateName.value_to_statename(cause.current_state)
trouble_ticket_id = None
trouble_ticket_link = None
if event[0].trouble_ticket:
trouble_ticket_id = event[0].trouble_ticket
trouble_ticket_link = tg.config['vigiboard_links.tt'] % {
'id': event[0].idcorrevent,
'host': event[1] and urllib.quote(event[1].encode('utf8'), '') or event[1],
'service': event[2] and urllib.quote(event[2].encode('utf8'), '') or event[2],
'tt': trouble_ticket_id and \
urllib.quote(trouble_ticket_id.encode('utf8'), '') or \
trouble_ticket_id,
}
return {
'trouble_ticket_link': trouble_ticket_link,
'trouble_ticket_id': trouble_ticket_id,
'state': state,
'id': event[0].idcorrevent,
'ack': ack,
}
def test_default_state(self):
"""L'état initial d'un hôte est 'UP'."""
assert_equals(u'UP', StateName.value_to_statename(
DBSession.query(self.klass).one().state.state))
def get_json_data(self, idcorrevent, *args, **kwargs):
"""
Renvoie les éléments pour l'affichage de la fenêtre de dialogue
contenant des détails sur un événement corrélé.
@param idcorrevent: identifiant de l'événement corrélé.
@type idcorrevent: C{int}
"""
# Obtention de données sur l'événement et sur son historique
host_query = DBSession.query(
Host.idhost.label("idsupitem"),
Host.idhost.label("idhost"),
Host.name.label("host"),
expr_null().label("service"),
)
lls_query = DBSession.query(
LowLevelService.idservice.label("idsupitem"),
Host.idhost.label("idhost"),
Host.name.label("host"),
LowLevelService.servicename.label("service"),
).join(
(Host, Host.idhost == LowLevelService.idhost),
)
supitems = union_all(lls_query, host_query, correlate=False).alias()
event = DBSession.query(
CorrEvent.idcorrevent,
CorrEvent.idcause,
supitems.c.idhost,
supitems.c.host,
supitems.c.service,
Event.message,
Event.initial_state,
Event.current_state,
Event.peak_state
).join(
(Event, Event.idevent == CorrEvent.idcause),
(supitems, supitems.c.idsupitem == Event.idsupitem),
).filter(CorrEvent.idcorrevent == idcorrevent
).first()
# On détermine les cartes auxquelles cet utilisateur a accès.
user_maps = []
max_maps = int(config['max_maps'])
is_manager = config.is_manager.is_met(request.environ)
if max_maps != 0 and (is_manager or
has_permission('vigimap-access').is_met(request.environ)):
items = DBSession.query(
Map.idmap,
Map.title,
func.lower(Map.title),
).distinct(
).join(
(MAP_GROUP_TABLE, MAP_GROUP_TABLE.c.idmap == Map.idmap),
(MapGroup, MapGroup.idgroup == MAP_GROUP_TABLE.c.idgroup),
(MapNodeHost, MapNodeHost.idmap == Map.idmap),
).order_by(func.lower(Map.title).asc()
).filter(MapNodeHost.idhost == event.idhost)
if not is_manager:
mapgroups = get_current_user().mapgroups(only_direct=True)
# pylint: disable-msg=E1103
items = items.filter(MapGroup.idgroup.in_(mapgroups))
# La valeur -1 supprime la limite.
if max_maps > 0:
# On limite au nombre maximum de cartes demandés + 1.
# Un message sera affiché s'il y a effectivement plus
# de cartes que la limite configurée.
items = items.limit(max_maps + 1)
user_maps = [(m.idmap, m.title) for m in items.all()]
context = {
'idcorrevent': idcorrevent,
'host': event.host,
'service': event.service,
'message': event.message,
'maps': user_maps,
'current_state': StateName.value_to_statename(event.current_state),
'initial_state': StateName.value_to_statename(event.initial_state),
'peak_state': StateName.value_to_statename(event.peak_state),
}
eventdetails = {}
for edname, edlink in enumerate(config['vigiboard_links.eventdetails']):
# Évite que les gardes ne se polluent entre elles.
local_ctx = context.copy()
# Les liens peuvent être conditionnés à l'aide
# d'une expression ou d'un callable qui agira
# comme un prédicat de test.
if 'only_if' in edlink:
if callable(edlink['only_if']):
display_link = edlink['only_if'](local_ctx)
else:
display_link = edlink['only_if']
if not display_link:
continue
if callable(edlink['uri']):
uri = edlink['uri'](local_ctx)
else:
uri = edlink['uri'] % local_ctx
eventdetails[unicode(edname)] = {
'url': url(uri),
'target': edlink.get('target', '_blank')
}
return dict(
current_state = StateName.value_to_statename(
event.current_state),
initial_state = StateName.value_to_statename(
event.initial_state),
peak_state = StateName.value_to_statename(
event.peak_state),
idcorrevent = idcorrevent,
host = event.host,
service = event.service,
eventdetails = eventdetails,
maps = user_maps,
idcause = event.idcause,
)
def test_default_state(self):
"""L'état initial d'un service de haut niveau est 'UNKNOWN'."""
assert_equals(u'UNKNOWN', StateName.value_to_statename(
DBSession.query(self.klass).one().state.state))
def get_data(self, event):
state = StateName.value_to_statename(event[0].cause.current_state)
return {
'state': state,
'occurrences': event[0].occurrence,
}
