def test_sql_escape_like(self):
"""
Teste les valeurs de retour de la fonction sql_escape_like.
On s'attend à ce que les '*' soient remplacées par '%',
et à ce que les '?' soient substitués par des '_'.
Il faut en outre que les '%' et les '_' de la
chaîne d'origine soient "échappés" par des '\\'.
"""
# On vérifie que les '%' sont bien "échappés".
self.assertEqual(sql_escape_like('%'), '\\%')
self.assertEqual(sql_escape_like('%aa%aa%'), '\\%aa\\%aa\\%')
# On vérifie que les '_' sont bien "échappés".
self.assertEqual(sql_escape_like('_'), '\\_')
self.assertEqual(sql_escape_like('_aa_aa_'), '\\_aa\\_aa\\_')
# On vérifie que les '*' sont bien remplacés par des '%'.
self.assertEqual(sql_escape_like('*'), '%')
self.assertEqual(sql_escape_like('*aa*aa*'), '%aa%aa%')
# On vérifie que les '?' sont bien remplacés par des '_'.
self.assertEqual(sql_escape_like('?'), '_')
self.assertEqual(sql_escape_like('?aa?aa?'), '_aa_aa_')
def handle_search_fields(self, query, search, state, subqueries):
if state != ITEMS:
return
if search.get('output'):
output = sql_escape_like(search['output'])
query.add_filter(Event.message.ilike(output))
def handle_search_fields(self, query, search, state, subqueries):
if state != ITEMS:
return
if search.get('host'):
host = sql_escape_like(search['host'])
query.add_filter(query.items.c.hostname.ilike(host))
def supitemgroup(self, supitemgroup, partial, noCache):
"""
Auto-compléteur pour les noms des groupes d'éléments supervisés.
@param supitemgroup: Motif qui doit apparaître dans le nom
du groupe d'éléments supervisés.
@type supitemgroup: C{unicode}
@return: Un dictionnaire dont la clé 'results' contient la liste
des noms de groupes d'élements supervisés correspondant
au motif donné et auxquels l'utilisateur a accès.
@rtype: C{dict}
"""
supitemgroup = sql_escape_like(supitemgroup)
user = get_current_user()
if not user:
return dict(results=[])
if partial:
supitemgroup += "%"
supitemgroups = DBSession.query(SupItemGroup.name).distinct().filter(SupItemGroup.name.ilike(supitemgroup))
if not config.is_manager.is_met(request.environ):
user_groups = [ug[0] for ug in user.supitemgroups() if ug[1]]
supitemgroups = supitemgroups.filter(SupItemGroup.idgroup.in_(user_groups))
supitemgroups = supitemgroups.all()
return dict(results=[s.name for s in supitemgroups])
def handle_search_fields(self, query, search, state, subqueries):
if state != ITEMS:
return
if search.get('service'):
service = sql_escape_like(search['service'])
query.add_filter(query.items.c.servicename.ilike(service))
def service(self, service, host, partial, noCache):
"""
Auto-compléteur pour les noms des services d'un hôte.
@param host: Nom d'hôte (optionnel) sur lequel s'applique
l'autocomplétion.
@type host: C{unicode}
@param service: Motif qui doit apparaître dans le nom de service.
@type service: C{unicode}
@note: Les caractères '?' et '*' peuvent être utilisés dans
le paramètre L{service} pour remplacer un caractère quelconque
ou une chaîne de caractères, respectivement.
Ex: 'ho?t*' permet de récupérer 'host', 'honte' et 'hostile',
mais pas 'hote' ou 'hopital'.
@return: Un dictionnaire dont la clé 'results' contient la liste
des noms de services configurés sur L{host} (ou sur n'importe
quel hôte si L{host} vaut None), correspondant au motif donné
et auxquels l'utilisateur a accès.
@rtype: C{dict}
"""
service = sql_escape_like(service)
user = get_current_user()
if not user:
return dict(results=[])
if partial:
service += "%"
hostgroup = SUPITEM_GROUP_TABLE.alias()
servicegroup = SUPITEM_GROUP_TABLE.alias()
services = (
DBSession.query(LowLevelService.servicename)
.distinct()
.outerjoin(
(Host, Host.idhost == LowLevelService.idhost),
(hostgroup, hostgroup.c.idsupitem == Host.idhost),
(servicegroup, servicegroup.c.idsupitem == LowLevelService.idservice),
)
.filter(LowLevelService.servicename.ilike(service))
.order_by(LowLevelService.servicename)
)
if not config.is_manager.is_met(request.environ):
user_groups = [ug[0] for ug in user.supitemgroups() if ug[1]]
services = services.filter(
or_(hostgroup.c.idgroup.in_(user_groups), servicegroup.c.idgroup.in_(user_groups))
)
if host:
services = services.filter(Host.name == host)
services = services.all()
return dict(results=[s.servicename for s in services])
def handle_search_fields(self, query, search, state, subqueries):
if state != ITEMS:
return
if search.get('trouble_ticket'):
tt = sql_escape_like(search['trouble_ticket'])
query.add_filter(CorrEvent.trouble_ticket.ilike(tt))
if search.get('ack'):
try:
query.add_filter(CorrEvent.ack == int(search['ack']))
except (ValueError, TypeError):
# On ignore silencieusement le critère de recherche erroné.
pass
def host(self, host, partial, noCache):
"""
Auto-compléteur pour les noms d'hôtes.
@param host: Motif qui doit apparaître dans le nom de l'hôte.
@type host: C{unicode}
@note: Les caractères '?' et '*' peuvent être utilisés dans
le paramètre L{host} pour remplacer un caractère quelconque
ou une chaîne de caractères, respectivement.
Ex: 'ho?t*' permet de récupérer 'host', 'honte' et 'hostile',
mais pas 'hote' ou 'hopital'.
@return: Un dictionnaire dont la clé 'results' contient la liste
des noms d'hôtes correspondant au motif donné en entrée
et auxquels l'utilisateur a accès.
@rtype: C{dict}
"""
host = sql_escape_like(host)
user = get_current_user()
if not user:
return dict(results=[])
if partial:
host += "%"
hostgroup = SUPITEM_GROUP_TABLE.alias()
servicegroup = SUPITEM_GROUP_TABLE.alias()
hostnames = (
DBSession.query(Host.name)
.distinct()
.outerjoin(
(hostgroup, hostgroup.c.idsupitem == Host.idhost),
(LowLevelService, LowLevelService.idhost == Host.idhost),
(servicegroup, servicegroup.c.idsupitem == LowLevelService.idservice),
)
.filter(Host.name.ilike(host))
.order_by(Host.name)
)
if not config.is_manager.is_met(request.environ):
user_groups = [ug[0] for ug in user.supitemgroups() if ug[1]]
hostnames = hostnames.filter(
or_(hostgroup.c.idgroup.in_(user_groups), servicegroup.c.idgroup.in_(user_groups))
)
hostnames = hostnames.all()
return dict(results=[h.name for h in hostnames])
def graph(self, graphname, host, partial, noCache):
"""
Auto-compléteur pour les noms des graphes.
@param graphname: Motif qui doit apparaître dans le nom du graphe.
@type graphname: C{unicode}
@param host: Nom de l'hôte auquel le graphe doit être rattaché.
@type host: C{unicode}
@return: Un dictionnaire dont la clé 'results' contient la liste
des noms des graphes portant sur L{host}, correspondant
au motif donné et auxquels l'utilisateur a accès.
@rtype: C{dict}
"""
graphname = sql_escape_like(graphname)
user = get_current_user()
if not user:
return dict(results=[])
if partial:
graphname += "%"
graphs = (
DBSession.query(Graph.name)
.distinct()
.join(
(GRAPH_PERFDATASOURCE_TABLE, GRAPH_PERFDATASOURCE_TABLE.c.idgraph == Graph.idgraph),
(PerfDataSource, PerfDataSource.idperfdatasource == GRAPH_PERFDATASOURCE_TABLE.c.idperfdatasource),
(Host, Host.idhost == PerfDataSource.idhost),
)
.filter(Graph.name.ilike(graphname))
.filter(Host.name == host)
.order_by(Graph.name)
)
if not config.is_manager.is_met(request.environ):
user_groups = [ug[0] for ug in user.supitemgroups() if ug[1]]
graphs = graphs.join((SUPITEM_GROUP_TABLE, SUPITEM_GROUP_TABLE.c.idsupitem == Host.idhost)).filter(
SUPITEM_GROUP_TABLE.c.idgroup.in_(user_groups)
)
graphs = graphs.all()
return dict(results=[g.name for g in graphs])
def searchHost(self, query):
"""
Affiche les résultats de la recherche par nom d'hôte.
La requête de recherche (C{query}) correspond à un préfixe
qui sera recherché dans le nom d'hôte. Ce préfixe peut
contenir les caractères '*' et '?' qui agissent comme des
"jokers".
@keyword query: Prefixe de recherche sur les noms d'hôtes
@type query: C{unicode}
"""
if not query:
redirect("searchHostForm")
return
query = sql_escape_like(query.strip())
user = get_current_user()
if user is None:
return dict(items=[])
# Récupère les hôtes auxquels l'utilisateur a réellement accès.
hosts = DBSession.query(
Host.name,
).distinct(
).join(
(SUPITEM_GROUP_TABLE, SUPITEM_GROUP_TABLE.c.idsupitem == \
Host.idhost),
).filter(Host.name.like(query + u'%')
).order_by(Host.name.asc(),)
# Les managers ont accès à tout.
# Les autres ont un accès restreint.
if not config.is_manager.is_met(request.environ):
supitemgroups = [sig[0] for sig in user.supitemgroups() if sig[1]]
hosts = hosts.join(
(GroupHierarchy, GroupHierarchy.idchild == \
SUPITEM_GROUP_TABLE.c.idgroup)
).filter(GroupHierarchy.idparent.in_(supitemgroups))
return dict(hosts=[h.name for h in hosts])
def hls(self, service, partial, noCache):
"""
Auto-compléteur pour les noms des services de haut niveau.
@param service: Motif qui doit apparaître dans le nom de service.
@type service: C{unicode}
@note: Les caractères '?' et '*' peuvent être utilisés dans
le paramètre L{service} pour remplacer un caractère quelconque
ou une chaîne de caractères, respectivement.
Ex: 'ho?t*' permet de récupérer 'host', 'honte' et 'hostile',
mais pas 'hote' ou 'hopital'.
@return: Un dictionnaire dont la clé 'results' contient la liste
des noms des services de haut niveau correspondant au motif
donné et auxquels l'utilisateur a accès.
@rtype: C{dict}
"""
service = sql_escape_like(service)
user = get_current_user()
if not user:
return dict(results=[])
if partial:
service += "%"
services = (
DBSession.query(HighLevelService.servicename)
.distinct()
.filter(HighLevelService.servicename.ilike(service))
.order_by(HighLevelService.servicename)
)
# if not config.is_manager.is_met(request.environ):
# user_groups = [ug[0] for ug in user.supitemgroups() if ug[1]]
# services = services.join(
# (SUPITEM_GROUP_TABLE, SUPITEM_GROUP_TABLE.c.idsupitem == \
# HighLevelService.idservice),
# ).filter(SUPITEM_GROUP_TABLE.c.idgroup.in_(user_groups))
services = services.all()
return dict(results=[s.servicename for s in services])
def perfdatasource(self, ds, host, partial, noCache):
"""
Auto-compléteur pour les noms des indicateurs de performance.
@param ds: Motif qui doit apparaître dans le nom de l'indicateur.
@type ds: C{unicode}
@param host: Nom de l'hôte auquel l'indicateur doit être rattaché.
@type host: C{unicode}
@return: Un dictionnaire dont la clé 'results' contient la liste
des noms des indicateurs de supervision sur L{host} correspondant
au motif donné et auxquels l'utilisateur a accès.
@rtype: C{dict}
"""
ds = sql_escape_like(ds)
user = get_current_user()
if not user:
return dict(results=[])
if partial:
ds += "%"
perfdatasources = (
DBSession.query(PerfDataSource.name)
.distinct()
.join((Host, Host.idhost == PerfDataSource.idhost))
.filter(PerfDataSource.name.ilike(ds))
.filter(Host.name == host)
.order_by(PerfDataSource.name)
)
if not config.is_manager.is_met(request.environ):
user_groups = [ug[0] for ug in user.supitemgroups() if ug[1]]
perfdatasources = perfdatasources.join(
(SUPITEM_GROUP_TABLE, SUPITEM_GROUP_TABLE.c.idsupitem == Host.idhost)
).filter(SUPITEM_GROUP_TABLE.c.idgroup.in_(user_groups))
perfdatasources = perfdatasources.all()
return dict(results=[ds.name for ds in perfdatasources])
def searchHostAndGraph(self, search_form_host, search_form_graph):
"""
Determination des couples (hote-graphe) repondant aux criteres de
recherche sur hote et/ou graphe.
Un critere peut correspondre a un intitule complet hote ou graphe
ou a un extrait.
@return: couples hote-graphe
@rtype: document json (sous forme de dict)
"""
limit = 100
user = get_current_user()
ids = []
labels = []
if user is None:
return dict(items=[])
# On a un nom d'indicateur, mais pas de nom d'hôte,
# on considère que l'utilisateur veut tous les indicateurs
# correspondant au motif, quel que soit l'hôte.
if search_form_graph:
if not search_form_host:
search_form_host = u'*'
search_form_host = sql_escape_like(search_form_host)
search_form_graph = sql_escape_like(search_form_graph)
items = DBSession.query(
Host.idhost.label('idhost'),
Host.name.label('hostname'),
Graph.idgraph.label('idgraph'),
Graph.name.label('graphname'),
).distinct().join(
(PerfDataSource, PerfDataSource.idhost == Host.idhost),
(GRAPH_PERFDATASOURCE_TABLE, \
GRAPH_PERFDATASOURCE_TABLE.c.idperfdatasource == \
PerfDataSource.idperfdatasource),
(Graph, Graph.idgraph == \
GRAPH_PERFDATASOURCE_TABLE.c.idgraph),
(SUPITEM_GROUP_TABLE, SUPITEM_GROUP_TABLE.c.idsupitem == \
Host.idhost),
).filter(Host.name.ilike(search_form_host)
).filter(Graph.name.ilike(search_form_graph)
).order_by(
Host.name.asc(),
Graph.name.asc(),
)
# On a ni hôte, ni indicateur. On renvoie une liste vide.
# Si l'utilisateur voulait vraiment quelque chose,
# il n'avait qu'à le demander.
elif not search_form_host:
return []
# Sinon, on a juste un motif pour un hôte.
# On renvoie la liste des hôtes correspondant.
else:
search_form_host = sql_escape_like(search_form_host)
items = DBSession.query(
Host.idhost.label('idhost'),
Host.name.label('hostname'),
).distinct().join(
(SUPITEM_GROUP_TABLE, SUPITEM_GROUP_TABLE.c.idsupitem == \
Host.idhost),
).filter(Host.name.ilike(search_form_host)
).order_by(Host.name.asc())
# Les managers ont accès à tout.
# Les autres ont un accès restreint.
if not config.is_manager.is_met(request.environ):
supitemgroups = [sig[0] for sig in user.supitemgroups() if sig[1]]
# pylint: disable-msg=E1103
items = items.join(
(GroupHierarchy, GroupHierarchy.idchild == \
SUPITEM_GROUP_TABLE.c.idgroup)
).filter(GroupHierarchy.idparent.in_(supitemgroups))
items = items.limit(limit + 1).all() # pylint: disable-msg=E1103
more_results = len(items) > limit
if not search_form_graph:
for i in xrange(min(limit, len(items))):
ids.append((items[i].idhost, None))
labels.append((items[i].hostname, None))
else:
for i in xrange(min(limit, len(items))):
ids.append((items[i].idhost, items[i].idgraph))
labels.append((items[i].hostname, items[i].graphname))
return dict(labels=labels, ids=ids, more=more_results)
