Exemplo n.º 1
0
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()
Exemplo n.º 2
0
    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()
Exemplo n.º 3
0
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)