def test_grouppath_representations(self):
"""Teste la représentation d'un chemin pour un groupe."""
add_supitemgroup(u'TestRoot', None)
root_path = DBSession.query(GroupPath).first()
self.assertEquals(u'/TestRoot', unicode(root_path))
self.assertEquals(u'<GroupPath "/TestRoot">', repr(root_path))
def create_deps(self):
# Le groupe "foobarbaz" est un descendant du groupe "Parent".
parent = functions.add_supitemgroup(u'Parent')
child = functions.add_supitemgroup(u'foobarbaz', parent)
# Positionnement des permissions.
functions.add_supitemgrouppermission(parent, u'indirect')
functions.add_supitemgrouppermission(child, u'direct')
def create_deps(self):
host = functions.add_host(u'foobarbaz')
# L'hôte appartient au groupe "Child".
parent = functions.add_supitemgroup(u'Parent')
child = functions.add_supitemgroup(u'Child', parent)
functions.add_host2group(host, child)
# Positionnement des permissions.
functions.add_supitemgrouppermission(parent, u'indirect')
functions.add_supitemgrouppermission(child, u'direct')
def create_deps(self):
# Les caractères "_" & "%" sont spéciaux en SQL.
# Leur usage permet de détecter les échappements abusifs (#943).
self.host = functions.add_host(u'a.b.c_d%e')
self.service = functions.add_lowlevelservice(self.host, u'foobarbaz')
# L'hôte appartient au groupe "Child".
parent = functions.add_supitemgroup(u'Parent')
child = functions.add_supitemgroup(u'Child', parent)
functions.add_host2group(self.host, child)
# Positionnement des permissions.
functions.add_supitemgrouppermission(parent, u'indirect')
functions.add_supitemgrouppermission(child, u'direct')
def test_change_dependencies_remove(self):
"""Gestion des changements: fichier supprimé"""
grouploader = GroupLoader()
grouploader.load_dir(self.datadir)
df.add_supitemgroup("to_be_removed")
before = DBSession.query(SupItemGroup).count()
# On doit créer un 2ème loader pour forcer le rechargement
# des instances depuis la base de données.
grouploader = GroupLoader()
grouploader.load_dir(self.datadir)
grouploader.cleanup()
after = DBSession.query(SupItemGroup).count()
self.assertEquals(after, before - 1)
def create_deps(self):
# Les caractères "_" & "%" sont spéciaux en SQL.
# Leur usage permet de détecter les échappements abusifs (#943).
self.host = functions.add_host(u'a.b.c_d%e')
functions.add_vigiloserver(u'localhost')
functions.add_application(u'vigirrd')
functions.add_perfdatasource(u'foobarbaz', self.host)
# L'hôte appartient au groupe "Child".
parent = functions.add_supitemgroup(u'Parent')
child = functions.add_supitemgroup(u'Child', parent)
functions.add_host2group(self.host, child)
# Positionnement des permissions.
functions.add_supitemgrouppermission(parent, u'indirect')
functions.add_supitemgrouppermission(child, u'direct')
def populate_DB():
""" Peuple la base de données. """
# On ajoute un groupe d'hôtes et un groupe de services.
supitemmanagers = functions.add_supitemgroup(u'managersgroup')
usergroup = UserGroup.by_group_name(u'users_with_access')
DBSession.add(DataPermission(
group=supitemmanagers,
usergroup=usergroup,
access=u'w',
))
DBSession.flush()
# On crée un 2 hôtes, et on les ajoute au groupe d'hôtes.
host1 = functions.add_host(u'host1')
host2 = functions.add_host(u'host2')
supitemmanagers.supitems.append(host1)
supitemmanagers.supitems.append(host2)
DBSession.flush()
# On crée 2 services de bas niveau, et on les ajoute au groupe de services.
service1 = functions.add_lowlevelservice(host1, u'service1')
service2 = functions.add_lowlevelservice(host2, u'service2')
supitemmanagers.supitems.append(service1)
supitemmanagers.supitems.append(service2)
DBSession.flush()
return ([host1, host2], [service1, service2])
def insert_deps():
"""Insère les dépendances nécessaires aux tests."""
timestamp = datetime.now()
hostgroup = functions.add_supitemgroup(u'foo')
host = functions.add_host(u'bar')
hostgroup.supitems.append(host)
DBSession.flush()
servicegroup = functions.add_supitemgroup(u'bar')
service = functions.add_lowlevelservice(host, u'baz')
servicegroup.supitems.append(service)
DBSession.flush()
event = functions.add_event(service, u'WARNING', u'Hello world', timestamp)
functions.add_correvent([event], timestamp=timestamp)
return (hostgroup, servicegroup)
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 setUp(self):
"""Initialisation avant chaque test."""
super(TestDetailsPluginMapsHostLimited, self).setUp()
# On fait manuellement ce que l'initialisation de VigiMap ferait
# (car on est dans les tests de VigiBoard, pas ceux de VigiMap).
root = functions.add_mapgroup(u'Root')
DBSession.add(Permission(permission_name=u'vigimap-access'))
print "Creation hote, service et cartes"
host = functions.add_host(u'localhost éçà')
functions.add_lowlevelservice(host, u'lls éçà')
sig = functions.add_supitemgroup(u'supitemgroup éçà')
functions.add_host2group(host, sig)
mg = functions.add_mapgroup(u'éçà', root)
m1 = functions.add_map(u'M1', root)
# La seconde carte appartient à "/Root/éçà"
# et permet de tester les accès indirects.
m2 = functions.add_map(u'M2', mg)
m3 = functions.add_map(u'M3', root)
# On ajoute l'hôte 2 fois sur M1 pour vérifier
# l'absense de doublons dans les liens.
print "Preparation cartes"
functions.add_node_host(host, 'h1', m1)
functions.add_node_host(host, 'h2', m1)
functions.add_node_host(host, 'h', m2)
functions.add_node_host(host, 'h', m3)
# Création de quelques utilisateurs.
print "Creation des comptes utilisateurs et reglages permissions"
functions.add_user(u'restricted', u'*****@*****.**',
u'restricted', u'restricted',
u'restricted')
functions.add_user(u'unrestricted', u'*****@*****.**',
u'unrestricted', u'unrestricted',
u'unrestricted')
functions.add_user(u'no_rights', u'*****@*****.**',
u'no_rights', u'no_rights',
u'no_rights')
# Les 3 utilisateurs ont accès à VigiBoard.
functions.add_usergroup_permission(u'no_rights', u'vigiboard-access')
functions.add_usergroup_permission(u'restricted', u'vigiboard-access')
functions.add_usergroup_permission(u'unrestricted', u'vigiboard-access')
# Mais seuls "restricted" et "unrestricted" ont accès à VigiMap.
functions.add_usergroup_permission(u'restricted', u'vigimap-access')
functions.add_usergroup_permission(u'unrestricted', u'vigimap-access')
# Ils voient tous les trois les événements dans VigiBoard...
functions.add_supitemgrouppermission(sig, 'no_rights')
functions.add_supitemgrouppermission(sig, 'restricted')
functions.add_supitemgrouppermission(sig, 'unrestricted')
# ... mais "restricted" ne peut voir que "M2" ...
functions.add_MapGroupPermission(mg, 'restricted')
# ... tandis que "unrestricted" voit les 3 cartes (par héritage).
functions.add_MapGroupPermission(root, 'unrestricted')
DBSession.flush()
transaction.commit()
def insert_deps(return_service):
"""
Insère les dépendances nécessaires aux tests.
@param return_service: Indique si les événements générés
concernent un hôte (False) ou un service de bas niveau (True).
@type return_service: C{bool}
@return: Renvoie un tuple avec le groupe d'hôte créé,
l'identifiant du L{CorrEvent} généré et enfin,
l'identifiant de l'L{Event} généré.
@rtype: C{tuple}
"""
timestamp = datetime.now()
hostgroup = functions.add_supitemgroup(u'foo')
host = functions.add_host(u'bar')
hostgroup.supitems.append(host)
DBSession.flush()
servicegroup = functions.add_supitemgroup(u'bar')
service = functions.add_lowlevelservice(host, u'baz')
servicegroup.supitems.append(service)
DBSession.flush()
if return_service:
event = functions.add_event(service, u'WARNING', u'', timestamp)
else:
event = functions.add_event(host, u'WARNING', u'', timestamp)
correvent = functions.add_correvent([event], timestamp=timestamp)
usergroup = UserGroup.by_group_name(u'users_with_access')
DBSession.add(DataPermission(
usergroup=usergroup,
group=hostgroup,
access=u'r',
))
DBSession.flush()
transaction.commit()
correvent = DBSession.query(CorrEvent).first()
event = DBSession.query(Event).first()
return (correvent.idcorrevent, event.idevent)
def populateDB():
"""
Peuple la base de données en ajoutant :
- 3 groupes d'hôtes ;
- 3 hôtes ;
- 3 utilisateurs.
Les objets construits respectent les matrices suivantes.
Matrice des utilisateurs et groupes d'utilisateurs :
+-------------------+-----------+---------------+-------+-----------+
| util. \ groupe | managers | powerusers | users | visitor |
+===================+===========+===============+=======+===========+
| manager | X | | | |
+-------------------+-----------+---------------+-------+-----------+
| poweruser | | X | | |
+-------------------+-----------+---------------+-------+-----------+
| user | | | X | |
+-------------------+-----------+---------------+-------+-----------+
| visitor | | | | X |
+-------------------+-----------+---------------+-------+-----------+
Matrice des groupes d'utilisateurs et des droits
sur les groupes d'objets supervisés :
+---------------------------+-----------+-----------+-----------+
| usergroup \ supitemgroup | mhg | hg1 | hg2 |
| | (host1) | (host2) | (host3) |
+===========================+===========+===========+===========+
| managers | / | / | / |
+---------------------------+-----------+-----------+-----------+
| powerusers | X | / | / |
+---------------------------+-----------+-----------+-----------+
| users | | X | |
+---------------------------+-----------+-----------+-----------+
| visitors | | | |
+---------------------------+-----------+-----------+-----------+
(X = accès explicite, / = accès implicite)
@return: Tuple contenant les trois hôtes créés.
@rtype: C{tuple} of C{vigilo.models.tables.Host}
"""
# Ajout d'un groupe d'hôtes principal
mainhostgroup = add_supitemgroup(u'mhg', None)
# Ajout d'un premier groupe d'hôtes de second niveau
hostgroup1 = add_supitemgroup(u'hg1', mainhostgroup)
# Ajout d'un second groupe d'hôtes de second niveau
hostgroup2 = add_supitemgroup(u'hg2', mainhostgroup)
# Ajout de trois hôtes
# On ajoute des caractères spéciaux pour détecter les
# conversions implicites Unicode <-> ASCII (et leurs erreurs).
host1 = add_host(u'host1 éà')
host2 = add_host(u'host2 éà')
host3 = add_host(u'host3 éà')
# Ajout du premier hôte dans le groupe d'hôtes principal.
add_host2group(host1, mainhostgroup)
# Ajout du deuxième hôte dans le premier
# groupe d'hôtes de second niveau.
add_host2group(host2, hostgroup1)
# Ajout du troisième hôte dans le second
# groupe d'hôtes de second niveau.
add_host2group(host3, hostgroup2)
# Ajout de trois groupes d'utilisateurs
poweruser_group = add_usergroup(u'powerusers')
user_group = add_usergroup(u'users')
visitor_group = add_usergroup(u'visitor')
# Ajout de trois utilisateurs
add_user(u'poweruser', u'*****@*****.**',
u'Power User', u'poweruserpass', u'powerusers')
add_user(u'user', u'*****@*****.**',
u'User', u'userpass', u'users')
add_user(u'visitor', u'*****@*****.**',
u'', u'visitorpass', u'visitor')
# Ajout des permissions sur le groupe d'hôtes
# principal pour le premier groupe d'utilisateurs
add_supitemgrouppermission(mainhostgroup, poweruser_group)
# Ajout des permissions sur le premier groupe d'hôtes
# secondaire pour le second groupe d'utilisateurs
add_supitemgrouppermission(hostgroup1, user_group)
# Ajout de la permission 'vigigraph-access' aux groupes d'utilisateurs
perm = Permission.by_permission_name(u'vigigraph-access')
add_usergroup_permission(poweruser_group, perm)
add_usergroup_permission(user_group, perm)
add_usergroup_permission(visitor_group, perm)
return (host1, host2, host3)
def populate_DB():
""" Peuple la base de données. """
# Création des 4 groupes de supitems :
# - 1 groupe racine 'root' ;
root = functions.add_supitemgroup(u'root')
# - 1 groupe principal 'maingroup' ;
maingroup = functions.add_supitemgroup(u'maingroup', root)
# - 2 sous-groupes 'group1' et 'group2', faisant tous
# les deux parties du groupe principal 'maingroup'.
group1 = functions.add_supitemgroup(u'group1', maingroup)
group2 = functions.add_supitemgroup(u'group2', maingroup)
# Création de 2 groupes d'utilisateurs (contenant chacun un utilisateur) :
vigiboard_perm = Permission.by_permission_name(u'vigiboard-access')
# - le premier avec des droits étendus
# (il a indirectement accès à tous les groupes de supitems) ;
usergroup = UserGroup(group_name=u'users_with_access')
usergroup.permissions.append(vigiboard_perm)
DBSession.add(DataPermission(
group = root,
usergroup = usergroup,
access = u'r',
))
user = User(
user_name=u'access',
fullname=u'',
email=u'user.has@access',
)
user.usergroups.append(usergroup)
DBSession.add(user)
# - le second avec des droits plus restreints
# (il n'a accès qu'au groupe de supitems 'group1').
usergroup = UserGroup(group_name=u'users_with_limited_access')
usergroup.permissions.append(vigiboard_perm)
DBSession.add(DataPermission(
group = group1,
usergroup = usergroup,
access = u'r',
))
user = User(
user_name=u'limited_access',
fullname=u'',
email=u'user.has.limited@access',
)
user.usergroups.append(usergroup)
DBSession.add(user)
DBSession.flush()
# Création de 3 hôtes (1 par groupe de supitems).
maingroup_host = functions.add_host(u'maingroup_host')
group1_host = functions.add_host(u'group1_host')
group2_host = functions.add_host(u'group2_host')
# Affectation des hôtes aux groupes.
maingroup.supitems.append(maingroup_host)
group1.supitems.append(group1_host)
group2.supitems.append(group2_host)
DBSession.flush()
# Création de 3 services de bas niveau (1 par hôte).
group1_service = functions.add_lowlevelservice(
group1_host, u'group1_service')
group2_service = functions.add_lowlevelservice(
group2_host, u'group2_service')
maingroup_service = functions.add_lowlevelservice(
maingroup_host, u'maingroup_service')
# Ajout de 6 événements (1 par supitem)
event1 = functions.add_event(maingroup_host, u'WARNING', u'foo')
event2 = functions.add_event(maingroup_service, u'WARNING', u'foo')
event3 = functions.add_event(group1_host, u'WARNING', u'foo')
event4 = functions.add_event(group1_service, u'WARNING', u'foo')
event5 = functions.add_event(group2_host, u'WARNING', u'foo')
event6 = functions.add_event(group2_service, u'WARNING', u'foo')
# Ajout de 5 événements corrélés (1 pour chaque évènement,
# sauf celui touchant le 'maingroup_service' qui sera rattaché
# à l'évènement corrélé causé par le 'maingroup_host').
functions.add_correvent([event1, event2])
functions.add_correvent([event3])
functions.add_correvent([event4])
functions.add_correvent([event5])
functions.add_correvent([event6])
transaction.commit()