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()