def add_mapsegment(from_node, to_node, map):
"""
Ajoute un segment entre deux éléments d'une carte.
@param from_node: Nœud de départ du segment.
@type from_node: L{tables.MapNode} ou C{basestring}
@param to_node: Nœud d'arrivée du segment.
@type to_node: L{tables.MapNode} ou C{basestring}
@param map: Carte sur laquelle le segment doit être ajouté.
@type map: L{tables.Map}
@return: Le segment nouvellement créé.
@rtype: L{tables.MapSegment}
"""
if isinstance(from_node, basestring):
from_node = tables.MapNode.by_map_label(map, unicode(from_node))
if isinstance(to_node, basestring):
to_node = tables.MapNode.by_map_label(map, unicode(to_node))
ms = tables.MapSegment(idfrom_node=from_node.idmapnode,
idto_node=to_node.idmapnode,
idmap=map.idmap,
color=u'#000000',
thickness=2)
DBSession.merge(ms)
DBSession.flush()
return ms
def add_ventilation(host, server, application):
"""
Ventile un hôte sur un serveur de supervision
pour une application donnée.
@param host: Hôte supervisé à ventiler.
@type host: C{basestr} ou L{tables.Host}
@param server: Serveur de supervision sur lequel ventiler.
@type server: C{basestr} ou L{tables.VigiloServer}
@param application: Application sur laquelle porte la ventilation.
@type application: C{basestr} ou L{tables.Application}
@return: Instance de ventilation créée.
Cette fonction lèvera une exception si l'hôte est déjà ventilé
sur un serveur de supervision pour l'application donnée.
@rtype: L{tables.Ventilation}
"""
if isinstance(host, basestring):
host = tables.Host.by_host_name(unicode(host))
if isinstance(server, basestring):
server = tables.VigiloServer.by_vigiloserver_name(unicode(server))
if isinstance(application, basestring):
application = tables.Application.by_app_name(unicode(application))
v = tables.Ventilation(
idhost=host.idhost,
idvigiloserver=server.idvigiloserver,
idapp=application.idapp
)
DBSession.merge(v)
DBSession.flush()
return v
def add_maphlslink(from_node, to_node, hls, map):
if isinstance(from_node, basestring):
from_node = tables.MapNode.by_map_label(map, unicode(from_node))
if isinstance(to_node, basestring):
to_node = tables.MapNode.by_map_label(map, unicode(to_node))
if isinstance(hls, basestring):
hls = tables.HighLevelService.by_service_name()
ms = tables.MapHlsLink(idfrom_node=from_node.idmapnode,
idto_node=to_node.idmapnode,
idref=hls.idservice,
idmap=map.idmap)
DBSession.merge(ms)
DBSession.flush()
return ms
def after_insert(self, mapper, connection, instance):
from vigilo.models.tables.state import State
from vigilo.models.tables.statename import StateName
from vigilo.models.tables.service import Service
# Pour un service (HLS ou LLS) : on initialise à UNKNOWN.
if isinstance(instance, Service):
state = StateName.statename_to_value(u"UNKNOWN")
# Pour un hôte : on initialise à UP.
else:
state = StateName.statename_to_value(u"UP")
s = State(idsupitem=instance.idsupitem, state=state, message=u"")
DBSession.merge(s)
return EXT_CONTINUE
def add_event(supitem, statename, message, timestamp=None):
"""
Ajoute un événement
@param supitem: ID ou instance du supitem
@type supitem: C{int} ou sous-classe de L{tables.SupItem}
@param statename: Nouvel état
@type statename: C{basestr}
@param message: Message associé au nouvel état.
@type message: C{basestr}
@param timestamp: timestamp de l'événement (par défaut: maintenant)
@type timestamp: C{datetime.datetime.DateTime}
"""
if isinstance(supitem, int):
idsupitem = supitem
elif isinstance(supitem, tables.Host):
idsupitem = supitem.idhost
elif isinstance(supitem, tables.service.Service):
idsupitem = supitem.idservice
elif isinstance(supitem, tables.SupItem):
idsupitem = supitem.idsupitem
if timestamp is None:
timestamp = datetime.now()
e = tables.Event(
idsupitem=idsupitem,
current_state=tables.StateName.statename_to_value(statename),
timestamp=timestamp,
message=unicode(message),
)
e = DBSession.merge(e)
DBSession.flush()
return e
def add_host_state(host, statename, message=None, timestamp=None):
"""
Met à jour l'état d'un hôte
@param host: Nom, ID, ou instance de l'hôte.
@type host: C{str} ou C{int} ou L{tables.Host}
@param statename: Nouvel état de l'hôte.
@type statename: C{basestr}
@param message: Message associé au nouvel état.
@type message: C{basestr}
"""
if isinstance(host, int):
idhost = host
elif isinstance(host, basestring):
idhost = tables.Host.by_name(host).idhost
else:
idhost = host.idhost
if timestamp is None:
timestamp = datetime.now()
s = tables.State(idsupitem=idhost,
state=tables.StateName.statename_to_value(statename),
message=unicode(message),
timestamp=timestamp,
)
s = DBSession.merge(s)
DBSession.flush()
return s
def add_svc_state(service, statename, message=None, timestamp=None):
"""
Met à jour l'état d'un service (bas niveau ou haut niveau).
@param service: Si c'est un tuple (hôte, service), on cherche un service de
bas niveau. Si c'est une chaîne on cherche un service de haut niveau.
Si c'est une instance on l'utilise telle quelle.
@type service: C{tuple} ou C{str} ou L{tables.LowLevelService} ou
L{tables.HighLevelService}
@param statename: Nouvel état du service.
@type statename: C{basestr}
@param message: Message associé au nouvel état.
@type message: C{basestr}
"""
if isinstance(service, tuple):
service = [ unicode(s) for s in service ]
service = tables.LowLevelService.by_host_service_name(*service)
elif isinstance(service, basestring):
service = tables.HighLevelService.by_service_name(service)
if timestamp is None:
timestamp = datetime.now()
s = tables.State(idsupitem=service.idservice,
state=tables.StateName.statename_to_value(statename),
message=unicode(message),
timestamp=timestamp,
)
s = DBSession.merge(s)
DBSession.flush()
return s
def add_mapllslink(from_node, to_node, lls, map):
if isinstance(from_node, basestring):
from_node = tables.MapNode.by_map_label(map, unicode(from_node))
if isinstance(to_node, basestring):
to_node = tables.MapNode.by_map_label(map, unicode(to_node))
if isinstance(lls, tuple):
lls = [unicode(s) for s in lls]
lls = tables.LowLevelService.by_host_service_name(*lls)
pds_in = add_perfdatasource('ineth0', lls.host)
pds_out = add_perfdatasource('outeth0', lls.host)
ms = tables.MapLlsLink(idfrom_node=from_node.idmapnode,
idto_node=to_node.idmapnode,
idref=lls.idservice, idmap=map.idmap,
ds_out=pds_out,
ds_in=pds_in)
DBSession.merge(ms)
DBSession.flush()
return ms
def setup(self):
"""Set up the fixture used to test the model."""
setup_db()
try:
print "Class being tested:", self.klass
new_attrs = {}
new_attrs.update(self.attrs)
new_attrs.update(self.do_get_dependencies())
self.obj = self.klass(**new_attrs)
self.obj = DBSession.merge(self.obj)
DBSession.flush()
return self.obj
except:
DBSession.rollback()
raise
def add_correvent(events, cause=None, status=tables.CorrEvent.ACK_NONE,
priority=4, timestamp=None):
"""
Ajoute un événement corrélé
@param events: liste d'évènements bruts à associer
@type events: C{list}
@param cause: évènement brut à utiliser comme cause. Si None, on prend le
premier de la liste L{events}.
@type cause: L{tables.Event} ou C{None}
@param status: état de prise en compte de l'évènement corrélé
@type status: C{int}
@param priority: priorité de l'événement corrélé
@type priority: C{int}
@param timestamp: timestamp de l'événement (par défaut: maintenant)
@type timestamp: C{datetime.datetime.DateTime}
"""
# on veut des instances de Event dans la liste
for i in range(len(events)):
if isinstance(events[i], int):
events[i] = DBSession.query(tables.Event).get(events[i])
if cause is None:
cause = events[0]
if timestamp is None:
timestamp = datetime.now()
ce = tables.CorrEvent(
idcause=cause.idevent,
events=events,
priority=priority,
ack=status,
timestamp_active=timestamp,
)
ce = DBSession.merge(ce)
DBSession.flush()
return ce
