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_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_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 test_status_no_change(self):
"""RevMan: statut sans changement"""
DBSession.add(tables.Version(name=RevisionManager.version_key, version=1))
DBSession.flush()
status = self.rev_mgr.status()
expected = {"added": [], "removed": [], "modified": []}
self.assertEqual(status, expected)
def setup_db():
"""Crée toutes les tables du modèle dans la BDD."""
#tmpdir = tempfile.mkdtemp(prefix="tests-vigiconf-")
#settings["database"]["sqlalchemy_url"] = "sqlite:///%s/vigilo.db" % tmpdir
transaction.abort()
# La vue GroupPath dépend de Group et GroupHierarchy.
# SQLAlchemy ne peut pas détecter correctement la dépendance.
# On crée le schéma en 2 fois pour contourner ce problème.
# Idem pour la vue UserSupItem (6 dépendances).
from vigilo.models.tables.grouppath import GroupPath
from vigilo.models.tables.usersupitem import UserSupItem
mapped_tables = metadata.tables.copy()
del mapped_tables[GroupPath.__tablename__]
del mapped_tables[UserSupItem.__tablename__]
metadata.create_all(tables=mapped_tables.itervalues())
metadata.create_all(tables=[GroupPath.__table__, UserSupItem.__table__])
DBSession.add(StateName(statename=u'OK', order=1))
DBSession.add(StateName(statename=u'UNKNOWN', order=2))
DBSession.add(StateName(statename=u'WARNING', order=3))
DBSession.add(StateName(statename=u'CRITICAL', order=4))
DBSession.add(StateName(statename=u'UP', order=1))
DBSession.add(StateName(statename=u'UNREACHABLE', order=2))
DBSession.add(StateName(statename=u'DOWN', order=4))
MapGroup(name=u'Root')
DBSession.flush()
def populate_db(bind):
from vigilo.models.session import DBSession
from vigilo.models import tables
permissions = {
'vigiboard-access':
'Gives access to VigiBoard',
'vigiboard-update':
'Allows users to update events',
'vigiboard-admin':
'Allows users to forcefully close open events',
'vigiboard-silence':
'Allows users to view and edit silence rules',
}
for (permission_name, description) in permissions.iteritems():
if not tables.Permission.by_permission_name(unicode(permission_name)):
DBSession.add(tables.Permission(
permission_name=unicode(permission_name),
description=unicode(description),
))
DBSession.flush()
def test_get_maps_limit(self):
"""La fonction get_maps doit récupérer les cartes du groupe"""
titles = [ u"test_map_%d" % i for i in range(10) ]
for title in titles:
add_map(title, self.obj)
DBSession.flush()
assert_equal(5, len(self.obj.get_maps(limit=5)))
def test_add_to_agregate(self):
"""Ajout d'un événement brut à un évènement corrélé déjà existant"""
# On crée 2 couples host/service.
host1 = functions.add_host(u'messagerie')
service1 = functions.add_lowlevelservice(host1, u'Processes')
service2 = functions.add_lowlevelservice(host1, u'CPU')
# On ajoute 1 couple événement/agrégat à la BDD.
event2 = functions.add_event(service2, u'WARNING', 'WARNING: CPU is overloaded')
events_aggregate1 = functions.add_correvent([event2])
# On ajoute un nouvel événement à la BDD.
event1 = functions.add_event(service1, u'WARNING', 'WARNING: Processes are not responding')
# On ajoute ce nouvel événement à l'agrégat existant.
ctx = helpers.ContextStub(42)
yield add_to_aggregate(
event1.idevent,
events_aggregate1.idcorrevent,
DummyDatabaseWrapper(True),
ctx,
123,
False
)
DBSession.flush()
# On vérifie que l'événement a bien été ajouté à l'agrégat.
DBSession.refresh(events_aggregate1)
expected = sorted([event1.idevent, event2.idevent])
actual = sorted([event.idevent for event in events_aggregate1.events])
print "actual = %r, expected = %r" % (actual, expected)
self.assertEquals(actual, expected)
def test_search_service_when_allowed_by_service(self):
"""
Teste la recherche par service avec des droits explicites
(droits accordés car l'utilisateur a explicitement les droits
sur ce service).
"""
# On crée un service avec une alerte.
# Le service est rattaché à un groupe de services
# pour lesquel l'utilisateur a les permissions.
servicegroup = insert_deps()[1]
usergroup = UserGroup.by_group_name(u'users')
DBSession.add(DataPermission(
group=servicegroup,
usergroup=usergroup,
access=u'r',
))
DBSession.flush()
transaction.commit()
# On envoie une requête avec recherche sur le service créé,
# on s'attend à recevoir 1 résultat.
response = self.app.get('/?service=baz',
extra_environ={'REMOTE_USER': '******'})
# Il doit y avoir 1 seule ligne de résultats.
rows = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr')
print "There are %d rows in the result set" % len(rows)
assert_equal(len(rows), 1)
# Il doit y avoir plusieurs colonnes dans la ligne de résultats.
cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
print "There are %d columns in the result set" % len(cols)
assert_true(len(cols) > 1)
def setUp(self):
super(TestDetailsPlugin, self).setUp()
perm = Permission.by_permission_name(u'vigiboard-access')
user = User(
user_name=u'access',
fullname=u'',
email=u'user.has@access',
)
usergroup = UserGroup(group_name=u'users_with_access')
usergroup.permissions.append(perm)
user.usergroups.append(usergroup)
DBSession.add(user)
DBSession.add(usergroup)
DBSession.flush()
user = User(
user_name=u'no_access',
fullname=u'',
email=u'user.has.no@access',
)
usergroup = UserGroup(group_name=u'users_without_access')
usergroup.permissions.append(perm)
user.usergroups.append(usergroup)
DBSession.add(user)
DBSession.add(usergroup)
DBSession.flush()
transaction.commit()
def test_migration(self):
"""Teste la migration (partielle/totale) du modèle."""
# Recherche des scripts de migration dans le dossier des tests.
module = u'vigilo.models.test.testdata'
scripts = get_migration_scripts(module)
expected_scripts = {
1: '001_Initial_version',
2: '002_Dummy',
3: '003_Dummy',
}
self.assertEquals(scripts, expected_scripts)
# On simule l'installation d'un nouveau modèle.
DBSession.add(tables.Version(
name=module,
version=1,
))
DBSession.flush()
# On vérifie qu'une migration jusqu'à un point fixe fonctionne.
migrate_model(DBSession.bind, module, scripts, 2)
version = DBSession.query(tables.Version).filter(
tables.Version.name == module).one()
self.assertEquals(version.version, 2)
# On annule la migration et on teste cette fois une migration
# jusqu'à la dernière version disponible.
version.version = 1
DBSession.flush()
migrate_model(DBSession.bind, module, scripts)
version = DBSession.query(tables.Version).filter(
tables.Version.name == module).one()
self.assertEquals(version.version, 3)
def test_add_single(self):
"""Ajout de permission sur un seul groupe."""
for (incode, outcode) in commands._permissions.iteritems():
print "Test permission %s" % incode
options = NamespaceStub(
permission=incode,
object_type=self._type,
usergroup=self._usergroup.group_name.encode('utf-8'),
object_group=self._group1.path.encode('utf-8'),
batch=False,
update=False,
commit=False, # la base de test est en mémoire,
# en la committant, on perdrait tout.
)
res = commands.cmd_add(options)
self.assertEquals(res, 0)
# Une seule permission doit exister en base de données.
# Elle doit porter sur le groupe 1 définis par le test
# et avoir le bon type d'accès.
dataperm = DBSession.query(tables.DataPermission).one()
self.assertEquals(dataperm.idgroup, self._group1.idgroup)
self.assertEquals(dataperm.idusergroup, self._usergroup.idgroup)
self.assertEquals(dataperm.access, outcode)
# Suppression de la permission pour le test
# du type de permission suivant.
DBSession.delete(dataperm)
DBSession.flush()
dataperm = DBSession.query(tables.DataPermission).first()
self.assertEquals(dataperm, None)
def runTest(self):
"""
Test de la récupération dans la BDD de l'identifiant d'un
item (hôte, service de haut niveau, ou service de bas niveau).
"""
setup_db()
DBSession.flush()
host1 = functions.add_host(u'messagerie')
lls1 = functions.add_lowlevelservice(host1, u'Processes')
hls1 = functions.add_highlevelservice(u'Connexion')
# On vérifie que la fonction get_supitem renvoie bien l'identifiant
# du host1 lorsqu'on lui passe son nom en paramètre.
self.assertEqual(host1.idhost, SupItem.get_supitem(host1.name, None))
# On vérifie que la fonction get_supitem renvoie bien l'identifiant
# du hls1 lorsqu'on lui passe son nom en paramètre.
self.assertEqual(hls1.idservice,
SupItem.get_supitem(None, hls1.servicename))
# On vérifie que la fonction get_supitem renvoie bien l'identifiant
# du lls1 lorsqu'on lui passe son nom en paramètre.
self.assertEqual(lls1.idservice,
SupItem.get_supitem(host1.name, lls1.servicename))
#Nettoyage de la BDD à la fin du test
del host1
del lls1
del hls1
DBSession.rollback()
DBSession.expunge_all()
teardown_db()
def test_pagination(self):
""" Pagination du tri """
# On crée autant d'événements qu'on peut en afficher par page + 1,
# afin d'avoir 2 pages dans le bac à événements.
host3 = functions.add_host(u'host3')
service3 = functions.add_lowlevelservice(
host3, u'service3')
DBSession.flush()
items_per_page = int(config['vigiboard_items_per_page'])
for i in xrange(items_per_page - 1):
event = functions.add_event(service3, u'WARNING', u'foo')
functions.add_correvent([event])
DBSession.flush()
transaction.commit()
# On affiche la seconde page de VigiBoard avec
# un tri par ordre décroissant sur le nom d'hôte
environ = {'REMOTE_USER': '******'}
response = self.app.get(
'/?page=2&sort=hostname&order=desc', extra_environ=environ)
# Il ne doit y avoir qu'une seule ligne de
# résultats concernant "service2" sur "host1"
hostnames = response.lxml.xpath(
'//table[@class="vigitable"]/tbody/tr/' \
'td[@class="plugin_hostname"]/text()')
assert_equal(hostnames, ['host1'])
servicenames = response.lxml.xpath(
'//table[@class="vigitable"]/tbody/tr/' \
'td[@class="plugin_servicename"]/text()')
assert_equal(servicenames, ['service2'])
def db_commit(self):
version_obj = Version.by_object_name(self.version_key)
if version_obj is None:
version_obj = Version(name=self.version_key)
version_obj.version = self.deploy_revision
DBSession.add(version_obj)
DBSession.flush()
def add_dependency(group, depended, distance=None):
"""
Ajoute une dépendance à un groupe de dépendances.
@param group: Groupe de dépendance (identifiant ou instance).
@type group: C{int} or L{tables.DependencyGroup}
@param depended: Élément à ajouter au groupe de dépendance,
sous la forme d'un tuple (hôte, service) décrivant l'élément
à ajouter.
@type depended: C{tuple}
"""
if isinstance(group, int):
idgroup = group
else:
idgroup = group.idgroup
if isinstance(depended, tables.SupItem):
dependency = depended
else:
host, service = depended
if host is None: # HLS
dependency = tables.HighLevelService.by_service_name(unicode(service))
elif service is None: # Host
dependency = tables.Host.by_host_name(unicode(host))
else: # LLS
dependency = tables.LowLevelService.by_host_service_name(
unicode(host), unicode(service))
DBSession.add(tables.Dependency(
idgroup=idgroup,
supitem=dependency,
distance=distance,
))
DBSession.flush()
def setUp(self):
super(TestHistoryTable, self).setUp()
perm = Permission.by_permission_name(u'vigiboard-access')
user = User(
user_name=u'access',
fullname=u'',
email=u'user.has@access',
)
usergroup = UserGroup(group_name=u'users_with_access')
usergroup.permissions.append(perm)
user.usergroups.append(usergroup)
DBSession.add(user)
DBSession.add(usergroup)
DBSession.flush()
user = User(
user_name=u'limited_access',
fullname=u'',
email=u'user.has.no@access',
)
usergroup = UserGroup(group_name=u'users_with_limited_access')
usergroup.permissions.append(perm)
user.usergroups.append(usergroup)
DBSession.add(user)
DBSession.add(usergroup)
DBSession.flush()
def test_cache(self):
"""Teste le cache des noms d'états."""
row = DBSession.query(StateName).first()
oldname = self.klass.value_to_statename(row.idstatename)
row.statename = row.statename + u'_'
DBSession.add(row)
DBSession.flush()
# On s'assure que le cache est bien utilisé :
# ie. il renvoie l'ancien nom de l'état.
currname = self.klass.value_to_statename(row.idstatename)
assert_equals(oldname, currname)
# De la même manière, le mapping inverse
# fonctionne toujours avec l'ancien nom.
assert_equals(
row.idstatename,
self.klass.statename_to_value(oldname)
)
# On provoque un rafraîchissement du cache.
assert_equals(
row.idstatename,
self.klass.statename_to_value(row.statename)
)
try:
self.klass.statename_to_value(oldname)
except KeyError:
# On s'attend à avoir une KeyError car l'ancien nom
# n'existe plus (ni dans la base, ni dans le cache).
pass
except Exception, e:
self.fail("Got an unexpected exception: %s (%s)" % (type(e), e))
def test_get_root_group_when_not_allowed(self):
"""Récupération des groupes racines de l'arbre sans les droits"""
# Récupération du groupe utilisé lors de ce test.
SupItemGroup.by_group_name(u'root')
# Création d'un nouvel utilisateur et d'un nouveau groupe
usergroup = UserGroup(group_name=u'new_users')
vigiboard_perm = Permission.by_permission_name(u'vigiboard-access')
usergroup.permissions.append(vigiboard_perm)
user = User(
user_name=u'new_user',
fullname=u'',
email=u'user.has.no@access',
)
user.usergroups.append(usergroup)
DBSession.add(user)
DBSession.flush()
transaction.commit()
# L'utilisateur est authentifié mais n'a aucun accès. Il
# cherche à obtenir la liste des groupes racines de l'arbre.
response = self.app.get('/get_groups',
extra_environ={'REMOTE_USER': '******'})
json = response.json
# On s'assure que la liste retournée est bien vide.
self.assertEqual(
json, {
'items': [],
'groups': []
}
)
def test_add_multiple_batch(self):
"""Ajout permission sur plusieurs groupes en mode batch."""
for (incode, outcode) in commands._permissions.iteritems():
print "Test permission %s" % incode
options = NamespaceStub(
permission=incode,
object_type=self._type,
usergroup=self._usergroup.group_name.encode('utf-8'),
object_group=self._group1.name.encode('utf-8'),
batch=True,
update=False,
commit=False, # la base de test est en mémoire,
# en la committant, on perdrait tout.
)
res = commands.cmd_add(options)
self.assertEquals(res, 0)
# 2 permissions doivent avoir été ajoutées.
dataperms = DBSession.query(tables.DataPermission).all()
self.assertEquals(2, len(dataperms))
idgroups = [self._group1.idgroup, self._group2.idgroup]
for dataperm in dataperms:
self.assertTrue(dataperm.idgroup in idgroups)
idgroups.remove(dataperm.idgroup)
self.assertEquals(dataperm.idusergroup, self._usergroup.idgroup)
self.assertEquals(dataperm.access, outcode)
# Suppression des permissions pour le test
# du type de permission suivant.
for dataperm in dataperms:
DBSession.delete(dataperm)
DBSession.flush()
dataperm = DBSession.query(tables.DataPermission).first()
self.assertEquals(dataperm, None)
def _add_permission(self, group, perm):
print "group = %r, perm = %r" % (unicode(group).encode('utf-8'), perm)
DBSession.add(tables.DataPermission(
idgroup=group.idgroup,
idusergroup=self._usergroup.idgroup,
access=unicode(perm),
))
DBSession.flush()
def add_graphgroup(name, parent=None):
name = unicode(name)
g = tables.GraphGroup.by_parent_and_name(parent, name)
if not g:
g = tables.GraphGroup(name=name, parent=parent)
DBSession.add(g)
DBSession.flush()
return g
def setUp(self):
helpers.teardown_db()
helpers.setup_db()
helpers.populate_statename()
self._insert_test_data()
DBSession.flush()
self.rd = helpers.RuleDispatcherStub()
return defer.succeed(None)
def add_perfdatasource2graph(ds, graph):
if isinstance(graph, int):
graph = DBSession.query(tables.Graph).get(graph)
if isinstance(ds, tuple):
ds = tables.PerfDataSource.by_host_and_source_name(*ds)
if ds not in graph.perfdatasources:
graph.perfdatasources.append(ds)
DBSession.flush()
def add_graph2group(graph, group):
if isinstance(group, basestring):
group = tables.GraphGroup.by_group_name(unicode(group))
if isinstance(graph, int):
graph = DBSession.query(tables.Graph).get(graph)
if graph not in group.graphs:
group.graphs.append(graph)
DBSession.flush()
def populate_DB():
""" Peuple la base de données en vue des tests. """
# On crée quatre hôtes de test.
host1 = functions.add_host(u"host1")
host2 = functions.add_host(u"host2")
host3 = functions.add_host(u"host3")
host4 = functions.add_host(u"host4")
DBSession.flush()
# On ajoute un service sur chaque hôte.
service1 = functions.add_lowlevelservice(host2, u"service1")
service2 = functions.add_lowlevelservice(host1, u"service2")
service3 = functions.add_lowlevelservice(host3, u"service3")
functions.add_lowlevelservice(host4, u"service4")
DBSession.flush()
# On crée un groupe de supitems et on y ajoute 'host1' et 'host4' en vue des
# tests portant sur les permissions
group1 = functions.add_supitemgroup(u"group1")
DBSession.add(group1)
functions.add_host2group(u"host1", u"group1")
functions.add_host2group(u"host4", u"group1")
DBSession.flush()
# On ajoute 2 utilisateurs.
functions.add_user(u"no_rights", u"*****@*****.**", u"no_rights", u"no_rights", u"no_rights")
functions.add_user(u"limited_rights", u"*****@*****.**", u"limited_rights", u"limited_rights", u"limited_rights")
functions.add_usergroup_permission(u"limited_rights", u"vigiboard-silence")
functions.add_supitemgrouppermission(u"group1", u"limited_rights")
DBSession.flush()
# On ajoute 4 règles de mise en silence.
functions.add_silence(
states=[u"UNKNOWN"], host=host1, service=None, user=u"manager", comment=u"foo", date=u"2000-01-01 00:00:00"
)
functions.add_silence(
states=[u"DOWN"],
host=host1,
service=service2,
user=u"unrestricted",
comment=u"bar",
date=u"2000-01-02 00:00:00",
)
functions.add_silence(
states=[u"WARNING", "CRITICAL"],
host=host2,
service=service1,
user=u"unrestricted",
comment=u"baz",
date=u"2000-01-03 00:00:00",
)
functions.add_silence(
states=[u"DOWN"], host=host3, service=None, user=u"manager", comment=u"qux", date=u"2000-01-04 00:00:00"
)
DBSession.flush()
transaction.commit()
def test_delete_tag(self):
"""Suppression d'un tag."""
self.obj.tags['foo'] = 'bar'
DBSession.flush()
assert_equals(1, len(self.obj.tags))
del self.obj.tags['foo']
DBSession.flush()
assert_equals(0, len(self.obj.tags))
def do_get_dependencies(self):
"""Création des dépendances du test."""
ModelTest.do_get_dependencies(self)
hls = functions.add_highlevelservice(u'HLS')
host = functions.add_host(u'myhost')
path = ImpactedPath(supitem=host)
DBSession.add(path)
DBSession.flush()
return dict(path=path, hls=hls)
