bf4a9b557f
whos.py a une option -b, qui permet de rajouter dans la recherche qu'on se limite aux bornes. Mais comme ça lui suffit pas, il revérifie a posteriori que les objets récupérés sont bien des bornes, alors que le critère de recherche est spécifique des bornes (dans ldap). C'est stupide, et depuis une des modifs, ça faisait de la merde. Donc je vire.
1325 lines
44 KiB
Python
Executable file
1325 lines
44 KiB
Python
Executable file
#! /usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
# Copyright (C) Frédéric Pauget
|
|
# Licence : GPLv2
|
|
|
|
u"""Ce script permet de recherche et d'afficher le détail d'une machine ou
|
|
d'un adhérent.
|
|
|
|
Usage: %(prog)s [options] <chaine de recherche>
|
|
|
|
La chaine de recherche peut être :
|
|
* soit un terme unique, dans ce cas la recherche sera effectuée sur les
|
|
champs en bleu ci-dessous.
|
|
* soit du type "champ1=valeur1&champ2!=valeur2 ...", les résultats seront
|
|
alors limités aux entrées correspondantes à tous les critères.
|
|
|
|
Les champs de recherche possibles sont :
|
|
%(champs_rech)s
|
|
|
|
Recherche sur prise possible (utiliser uniquement ce champ dans ce cas).
|
|
|
|
Les options de recherches sont :
|
|
* limitations sur l'affichage :
|
|
-a ou --adherent : limitation de l'affichage aux adhérents
|
|
-m ou --machine : limitation de l'affichage aux machines
|
|
-c ou --club : limitation de l'affichage aux clubs
|
|
-b ou --bornes : limitation de l'affichage aux bornes wifi
|
|
--crans : recherche uniquement les machines du crans
|
|
* options d'affichage :
|
|
-t ou --tech : affichages des infos techniques des machines
|
|
à la place des infos administratives dans les résumés.
|
|
-i ou --ipsec : montre la clef wifi (anciennement ipsec) des machines wifi
|
|
-l <num> ou --limit=<num> : limite du nombre de résultats pour utiliser
|
|
le mode d'affichage condensé au lieu du mode détaillé (défaut %(limit_aff_details)i)
|
|
-L <num> ou --limit-historique=<num> : limitation du nombre de lignes
|
|
d'historique affichées (défaut %(limit_aff_historique)i)
|
|
-d <num> ou --limit-blacklist=<num> : limitation du nombre de lignes
|
|
d'historique des déconnexions affichées (défaut %(limit_aff_blacklist)i)
|
|
-s ou --ssh : affiche les fingerprint ssh des machines
|
|
"""
|
|
|
|
try:
|
|
import sys,locale
|
|
|
|
loc = locale.getdefaultlocale()
|
|
if loc[1]:
|
|
sys.reallysetdefaultencoding(loc[1])
|
|
except:
|
|
pass
|
|
|
|
base = None
|
|
|
|
from time import strftime, localtime, time
|
|
from ldap_crans import is_actif, crans_ldap, ann_scol, AssociationCrans, hostname
|
|
from ldap_crans import MachineCrans, MachineWifi, BorneWifi
|
|
from ldap_crans import Adherent
|
|
from affich_tools import *
|
|
from config import rid
|
|
import user_tests
|
|
import subprocess, commands
|
|
|
|
limit_aff_details = 1
|
|
limit_aff_machines = 15
|
|
limit_aff_historique = 4
|
|
limit_aff_blacklist = 4
|
|
aff_ipsec = 0
|
|
aff_ssh = 0
|
|
|
|
################################################################################
|
|
### Fonctions utiles
|
|
|
|
def indicatif (num):
|
|
"""
|
|
Sépare l'indicatif de nationalité du reste d'un numéro de téléphone
|
|
"""
|
|
if num[0:2] != '00':
|
|
return ('', num)
|
|
if num[2] == '1':
|
|
return ('1 '+num[3:6], num[6:])
|
|
if num[2] in ['0','7']:
|
|
return (num[2], num[3:])
|
|
# indicatifs nationaux à 2 chiffres
|
|
ids = [20, 27, 36, 86, 98]
|
|
ids.extend(range(30,35))
|
|
ids.extend(range(39,42))
|
|
ids.extend(range(43,50))
|
|
ids.extend(range(51,59))
|
|
ids.extend(range(60,67))
|
|
ids.extend(range(81,85))
|
|
ids.extend(range(90,96))
|
|
if int(num[2:4]) in ids:
|
|
return (num[2:4], num[4:])
|
|
return (num[2:5], num[5:])
|
|
|
|
def format_tel (num):
|
|
"""
|
|
Formate un numéro de téléphone
|
|
* Remplace un éventuel "00" au début par un "+"
|
|
* Insère des espaces pour que ce soit lisible
|
|
"""
|
|
res = ''
|
|
(indic, reste) = indicatif(num)
|
|
if indic != '':
|
|
res += '+' + indic + ' '
|
|
l = len(reste)
|
|
if l%2 == 1:
|
|
res += reste[0] + ' '
|
|
for i in range(l%2,l,2):
|
|
res += reste[i:i+2] + ' '
|
|
return res
|
|
|
|
################################################################################
|
|
|
|
def aff(qqch,mtech=0) :
|
|
""" Affichage de qqch.
|
|
qqch peut être une liste d'instances des classes adhérent ou machine
|
|
(un seul type dans la liste) dans ce cas :
|
|
* si la longueur de la liste est inférieure à limit_aff_details
|
|
affiche les propriétés détaillées de chaque élément.
|
|
* sinon résume dans un tabeau des principales propriétés
|
|
si qqch est une instance seul la traité comme une liste à une élément
|
|
Si mtech = 1 affiches les infomations techniques des machines plutot
|
|
qu'administratives dans le tableau des propriétés
|
|
"""
|
|
if type(qqch) != list :
|
|
qqch = [ qqch ]
|
|
|
|
if len(qqch) > limit_aff_details :
|
|
t = qqch[0].idn
|
|
if t == 'aid':
|
|
cprint(adhers_brief(qqch))
|
|
elif t == 'mid':
|
|
if mtech:
|
|
cprint(list_machines(qqch))
|
|
else:
|
|
cprint(machines_brief(qqch))
|
|
elif t == 'cid':
|
|
cprint(clubs_brief(qqch))
|
|
else :
|
|
i = 0
|
|
for c in qqch :
|
|
t = c.idn
|
|
if i: cprint(u'='*80, 'cyan')
|
|
i = 1
|
|
if t == 'aid':
|
|
cprint(adher_details(c).strip())
|
|
elif t == 'mid':
|
|
cprint(machine_details(c).strip())
|
|
elif t == 'cid':
|
|
cprint(club_details(c).strip())
|
|
|
|
# affiche le nombre de résultats
|
|
if len(qqch) > 1:
|
|
cprint(u"Total: %d" % len(qqch))
|
|
|
|
def adhers_brief(adhers) :
|
|
"""
|
|
Formatage sous forme de tableau des infos sur la liste d'adhérent fournie :
|
|
* aid
|
|
* prénom nom
|
|
* chambre
|
|
* machines
|
|
"""
|
|
data = []
|
|
|
|
# Copie locale triée par (nom, prenom)
|
|
adhers = adhers[:]
|
|
adhers.sort(lambda x, y: cmp((x.nom(), x.prenom()), (y.nom(), y.prenom())))
|
|
|
|
for a in adhers:
|
|
## État administratif
|
|
ok = u'\x1b[1;32mo\x1b[1;0m'
|
|
ook = u'\x1b[1;32mO\x1b[1;0m'
|
|
nok = u'\x1b[1;31mn\x1b[1;0m'
|
|
# Paiement
|
|
if ann_scol in a.paiement():
|
|
if 'p' in a.controle(): paid = ook
|
|
else: paid = ok
|
|
elif isinstance(a,Adherent) and not a.adherentPayant(): paid = coul('G', 'bleu')
|
|
else: paid = nok
|
|
|
|
# Précablage
|
|
if ann_scol+1 in a.paiement() : paid = coul(paid,'f_vert')
|
|
|
|
# Carte d'étudiant
|
|
if ann_scol in a.carteEtudiant():
|
|
if 'c' in a.controle(): carte = ook
|
|
else: carte = ok
|
|
else : carte = nok
|
|
|
|
machines = ''
|
|
# Récupération des machines
|
|
if len(adhers) <= limit_aff_machines:
|
|
for machine in a.machines() :
|
|
nom = machine.nom().split('.')[0]
|
|
if machine.blacklist_actif() : k = 'rouge'
|
|
elif isinstance(machine, MachineWifi): k = 'cyan'
|
|
else : k= ''
|
|
if machines : machines += ', ' + coul(nom,k)
|
|
else : machines = coul(nom,k)
|
|
else:
|
|
machines = None
|
|
# Données
|
|
if len(adhers) <= limit_aff_machines:
|
|
data.append([a.id(), a.Nom(), a.chbre(), paid, carte, machines])
|
|
else:
|
|
data.append([a.id(), a.Nom(), a.chbre(), paid, carte])
|
|
|
|
if len(adhers) <= limit_aff_machines:
|
|
return u"Machines en rouge = machines avec limitation de services\n" + \
|
|
u"P : paiement année en cours, le fond vert indique le précâblage (G bleu = inscription gratuite)\n" + \
|
|
u"C : carte d'étudiant année en cours\n" + \
|
|
tableau(data,
|
|
titre = [u'aid', u'Prénom Nom', u'Chbre', u'P', u'C', u'Machines'],
|
|
largeur = [5, 30, 5, 1, 1, '*'],
|
|
alignement = ['d', 'c', 'g', 'c', 'c', 'c'])
|
|
else:
|
|
return u"Machines en rouge = machines avec limitation de services\n" + \
|
|
u"P : paiement année en cours, le fond vert indique le précâblage (G bleu = inscription gratuite)\n" + \
|
|
u"C : carte d'étudiant année en cours\n" + \
|
|
tableau(data,
|
|
titre = [u'aid', u'Prénom Nom', u'Chbre', u'P', u'C'],
|
|
largeur = [5, '*', 5, 1, 1],
|
|
alignement = ['d', 'c', 'g', 'c', 'c'])
|
|
|
|
def machines_brief(machines) :
|
|
"""
|
|
Formatage sous forme d'un tableau des propriétés de la liste de machine :
|
|
* mid
|
|
* rid
|
|
* type (serveur, adm, fil, wifi, adm, borne)
|
|
* nom
|
|
* adresse IP
|
|
* adresse MAC
|
|
* si blacklistée
|
|
"""
|
|
data = []
|
|
|
|
# Copie locale triée par nom
|
|
machines = machines[:]
|
|
machines.sort(lambda x, y: cmp(x.nom(), y.nom()))
|
|
|
|
for m in machines :
|
|
t, bl = __bases_machines(m)
|
|
|
|
# Propriétaire
|
|
a = m.proprietaire()
|
|
p = a.Nom()
|
|
|
|
# A jour administrativement
|
|
if ann_scol not in a.paiement() or ann_scol not in a.carteEtudiant():
|
|
if isinstance(a, Adherent) and not a.adherentPayant():
|
|
p = coul(p, 'bleu')
|
|
else:
|
|
p = coul(p,'rouge')
|
|
|
|
# Données
|
|
data.append([m.id(), m.rid() , t, m.nom().split('.')[0], p, a.chbre(), bl])
|
|
|
|
return u"Le propriétaire en rouge signale un problème administratif, en bleu une inscription gratuite\n" + \
|
|
tableau(data,
|
|
titre = [u'mid', u'rid', u'Type', u'Nom de machine', u'Propriétaire', u'Chbre', u'Limitation'],
|
|
largeur = [5, 5, 13, 18, '*', 5, 10],
|
|
alignement = ['d', 'd', 'c', 'c', 'c', 'g', 'c'])
|
|
|
|
def clubs_brief(clubs) :
|
|
"""
|
|
Formatage sous forme de tableau des infos sur la liste de clubs fournie :
|
|
* cid
|
|
* nom
|
|
* local
|
|
* machines
|
|
"""
|
|
data = []
|
|
|
|
# Copie locale triée par Nom
|
|
clubs = clubs[:]
|
|
clubs.sort(lambda x, y: cmp(x.Nom(), y.Nom()))
|
|
|
|
for c in clubs :
|
|
## État administratif
|
|
ok = u'\x1b[1;32mo\x1b[1;0m'
|
|
ook = u'\x1b[1;32mO\x1b[1;0m'
|
|
nok = u'\x1b[1;31mn\x1b[1;0m'
|
|
# Paiement
|
|
if ann_scol in c.paiement():
|
|
if 'p' in c.controle(): paid = ook
|
|
else: paid = ok
|
|
else : paid = nok
|
|
|
|
# Précablage
|
|
if ann_scol+1 in c.paiement() : paid = coul(paid,'f_vert')
|
|
|
|
machines = ''
|
|
# Récupération des machines
|
|
for machine in c.machines() :
|
|
nom = machine.nom().split('.')[0]
|
|
if machine.blacklist_actif() : k = 'rouge'
|
|
else : k= ''
|
|
if machines : machines += ', ' + coul(nom,k)
|
|
else : machines = coul(nom,k)
|
|
|
|
# Responsable
|
|
try:
|
|
resp = c.responsable().Nom()
|
|
except ValueError, e:
|
|
resp = e
|
|
|
|
# Données
|
|
data.append([c.id() , c.Nom(), c.local(), paid, resp, machines])
|
|
|
|
return u"Machines en rouge = machines avec limitation de services\n" + \
|
|
u"P : signature charte année en cours, le fond vert indique le précâblage\n" + \
|
|
tableau(data,
|
|
titre = [u'cid', u'Nom ', u'Local', u'P', u'Responsable', u'Machines'],
|
|
largeur = [5, '*', 6, 1, 21, 15],
|
|
alignement = ['d', 'c', 'g', 'c', 'c', 'c'])
|
|
|
|
|
|
def list_machines(machines) :
|
|
"""
|
|
Formatage sous forme d'un tableau des propriétés de la liste de machine :
|
|
* mid
|
|
* type (fixe ou wifi)
|
|
* nom
|
|
* adresse IP
|
|
* adresse MAC
|
|
* si blacklistée
|
|
"""
|
|
data = []
|
|
|
|
# Copie locale triée par nom
|
|
machines = machines[:]
|
|
machines.sort(lambda x, y: cmp(x.nom(), y.nom()))
|
|
|
|
for m in machines :
|
|
t, bl = __bases_machines(m)
|
|
|
|
# Données
|
|
data.append([m.id(), t, m.nom().split('.')[0], m.ip(), m.mac(), bl])
|
|
|
|
return tableau(data,
|
|
titre = [u'mid', u'Type', u'Nom de machine', u'Adresse IP', u'Adresse MAC', u'Limitation'],
|
|
largeur = [5, 4, '*', 17, 19, 10],
|
|
alignement = ['d', 'c', 'c', 'c', 'c', 'c'])
|
|
|
|
def list_bornes(bornes) :
|
|
"""
|
|
Formatage sous forme d'un tableau des propriétés de la liste de bornes wifi :
|
|
* mid
|
|
* nom
|
|
* adresse IP
|
|
* adresse MAC
|
|
* État
|
|
* puissance
|
|
* canal
|
|
* lieu (la première remarque en fait)
|
|
"""
|
|
data = []
|
|
|
|
# Copie locale triée par nom
|
|
bornes = bornes[:]
|
|
bornes.sort(lambda x, y: cmp(x.nom(), y.nom()))
|
|
|
|
ok = u'\x1b[1;32mu\x1b[1;0m'
|
|
nok = u'\x1b[1;31md\x1b[1;0m'
|
|
for b in bornes :
|
|
t, bl = __bases_machines(b)
|
|
|
|
# Données
|
|
try :
|
|
l = [x for x in b.info() if not x[0]=='<'][0]
|
|
if len(l) > 11 :
|
|
l = l[0:11]
|
|
except :
|
|
l = u'????'
|
|
|
|
if borne_etat(b.nom()):
|
|
etat = ok
|
|
else:
|
|
etat = nok
|
|
|
|
if '-' in b.puissance() :
|
|
puiss = coul(b.puissance(),'rouge')
|
|
else :
|
|
puiss = b.puissance()
|
|
|
|
data.append([b.id(), b.rid(), b.nom().split('.')[0], b.ip(), b.mac(), etat, b.canal(), puiss, b.prise(), l])
|
|
|
|
return u"Can=canaux, P=puissance, E=état\n" + \
|
|
tableau(data,
|
|
titre = [u'mid', u'rid', u'Nom', u'Adresse IP', u'Adresse MAC', u'E', u'Can', u'P', u'Pris', u'Lieu'],
|
|
largeur = [5, 5, 23, 15, 17, 1, 5, 3, 4, '*'],
|
|
alignement = ['d', 'd', 'c', 'c', 'c', 'c', 'c', 'c', 'g', 'c'])
|
|
|
|
def adher_details(adher) :
|
|
"""
|
|
Affichage du détail des propriétés d'un adhérent
|
|
"""
|
|
f=u''
|
|
# Aid
|
|
f+= coul(u'aid=%s ' % adher.id() ,'bleu')
|
|
# Nom, prenom
|
|
f += coul(u'Nom : ','gras') + "%s\n" % adher.Nom()
|
|
|
|
# Mail
|
|
GL = RMH = u''
|
|
if adher.mail() == '' or adher.compte() == '':
|
|
f += coul(u'Adresse mail : ','gras')
|
|
if adher.mail() == '':
|
|
f += coul('INCONNUE','rouge')
|
|
elif adher.mail_invalide():
|
|
f += coul(adher.mail(),'rouge')
|
|
else:
|
|
f += adher.mail()
|
|
f += "\n"
|
|
else :
|
|
f += coul(u'Login : ','gras')
|
|
if adher.mail_invalide():
|
|
f += coul(adher.compte(),'rouge')
|
|
else:
|
|
f += adher.compte()
|
|
f += "\t"
|
|
# controurneGreylisting
|
|
if not adher.contourneGreylist():
|
|
GL = u' (%s)'%coul(u'GreyList','gris')
|
|
if adher.rewriteMailHeaders():
|
|
RMH = u' (%s)'%coul(u'réécriture en-têtes mail','gris')
|
|
|
|
alias = u', '.join([adher.canonical_alias()] + adher.alias())
|
|
if alias:
|
|
if alias[0] == u',':
|
|
# Canonical étéait vide
|
|
alias = alias[2:]
|
|
f += coul(u'Alias : ','gras') + alias
|
|
f += GL
|
|
f += RMH
|
|
f += u'\n'
|
|
if len(adher.gpgFingerprint()) > 0:
|
|
f += u"\n".join([coul(u'Fingerprint GPG : ', 'gras') + u"%s" % (i) for i in adher.gpgFingerprint()])+"\n"
|
|
try:
|
|
forward = file("/home/%s/.forward" % adher.compte()).readlines()
|
|
if len(forward) > 1:
|
|
forward = forward[0].strip() + u" ...\n"
|
|
elif len(forward) == 1:
|
|
forward = forward[0].strip() + u"\n"
|
|
if forward:
|
|
f += coul(u'Redirection : ', 'gras') + forward
|
|
except IOError, e:
|
|
# Pas de .forward, ou .forward privé... on laisse tomber
|
|
pass
|
|
f += coul(u'Dernière connexion : ', 'gras')
|
|
timestamp = adher.derniereConnexion()
|
|
if timestamp == 0:
|
|
f += coul(u'Jamais', 'rouge')
|
|
else:
|
|
f += coul(strftime('%d/%m/%Y %H:%M', localtime(timestamp)),
|
|
time()-timestamp > 32*24*3600 and 'rouge' or '')
|
|
f += u"\n"
|
|
|
|
# État administratif
|
|
f += coul("Date d'inscription : ", "gras")
|
|
f += strftime('%d/%m/%Y %H:%M', localtime(adher.dateInscription()))
|
|
f += coul(u'\nÉtat administratif : ','gras')
|
|
jour=1
|
|
if ann_scol not in adher.carteEtudiant() :
|
|
f += coul(u"manque carte d'étudiant",'violet')
|
|
jour = 0
|
|
if ann_scol not in adher.paiement() :
|
|
if not jour : f += ' et '
|
|
if isinstance(adher, Adherent) and not adher.adherentPayant():
|
|
f += coul(u"inscription gratuite ", 'bleu')
|
|
else:
|
|
f += coul(u"cotisation %s/%d non réglée"% (ann_scol, ann_scol+1 ),'violet')
|
|
jour = 0
|
|
|
|
if jour :
|
|
f += coul(u"à jour",'vert')
|
|
f += '\n'
|
|
|
|
# Telephone
|
|
tel = adher.tel()
|
|
if tel != 'inconnu' :
|
|
f += coul(u'Numéro de téléphone : ','gras') + "%s\n" % format_tel(tel).ljust(12)
|
|
|
|
# Adresse
|
|
chbre = adher.chbre()
|
|
if chbre == 'EXT' :
|
|
# Adhérent extérieur
|
|
addr = adher.adresse()
|
|
if addr[0] :
|
|
f += coul(u'Adresse : ','gras')
|
|
f += addr[0] + u'\n'
|
|
if addr[1] != ' ' : f += u' ' + addr[1] + u'\n'
|
|
f+= u' ' + addr[2] + u' ' + addr[3] + '\n'
|
|
elif chbre == '????' :
|
|
f += coul(u'Chambre invalide\n','violet')
|
|
else :
|
|
# Chambre + prise (d'après annuaire)
|
|
etat, vlans, cablage = prise_etat(adher.chbre())
|
|
f += coul(u'Chambre : ','gras') + u"%s " % chbre
|
|
f += u'(%s)' % etat
|
|
f += u'\n'
|
|
f += coul(u'Brassage : ','gras')
|
|
f += cablage
|
|
f += u'\n'
|
|
# VLAN
|
|
if vlans :
|
|
f += coul(u'VLAN : ','gras') + u'%s' % vlans
|
|
f += u'\n'
|
|
|
|
# Études
|
|
if adher.etudes(1).isdigit() :
|
|
f += coul(u'Études : ','gras')+ "%s %s%s\n" % \
|
|
( adher.etudes(0), adher.etudes(1), adher.etudes(2) )
|
|
elif adher.etudes(0) :
|
|
f += coul(u'Études : ','gras')+ "%s %s %s\n" % \
|
|
( adher.etudes(0), adher.etudes(1), adher.etudes(2) )
|
|
|
|
# Solde
|
|
solde = adher.solde()
|
|
if solde :
|
|
f += coul(u'Solde : ','gras')
|
|
if solde < 0 :
|
|
f+= coul(str(solde).replace('.',','),'rouge')
|
|
else :
|
|
f += str(solde).replace('.',',')
|
|
f += u" Euros\n"
|
|
|
|
# Role dans l'assoce
|
|
d = adher.droits()
|
|
if d :
|
|
f += coul(u"Droits sur les serveurs : ",'gras') + ', '.join(d)
|
|
if adher.droitsGeles():
|
|
f += coul(u" (droits gelés car pas cotisé cette année)",'bleu')
|
|
f += u'\n'
|
|
|
|
# Paiement
|
|
if adher.paiement() :
|
|
if len(adher.paiement()) == 1 :
|
|
f += coul(u'Cotisation payée pour l\'année scolaire :','gras')
|
|
else :
|
|
f += coul(u'Cotisation payée pour les années scolaires :','gras')
|
|
g = u''
|
|
for an in adher.paiement() : g += u" %i-%i" % ( an, an+1 )
|
|
if len(g) > 35 : f += '\n\t'
|
|
f += g
|
|
if 'p' in adher.controle(): f += coul(u' (OK)', 'vert')
|
|
f += u'\n'
|
|
|
|
# Cartes d'étudiant fournie
|
|
if adher.carteEtudiant() :
|
|
if len(adher.carteEtudiant()) == 1 :
|
|
f += coul(u"Carte d'étudiant fournie pour l'année scolaire :",'gras')
|
|
else :
|
|
f += coul(u"Carte d'étudiant fournie pour les années scolaires :",'gras')
|
|
g = u''
|
|
for an in adher.carteEtudiant() : g += u" %i-%i" % ( an, an+1 )
|
|
if len(g) > 25 : f += '\n\t'
|
|
f += g
|
|
if 'c' in adher.controle(): f += coul(u' (OK)', 'vert')
|
|
f += u'\n'
|
|
|
|
f += _blacklist(adher)
|
|
f += _info(adher)
|
|
f += _hist(adher)
|
|
|
|
# Formatage des machines aussi
|
|
f += coul(u'Machine(s) : ','gras')
|
|
m = adher.machines()
|
|
if m :
|
|
f += u'\n' + list_machines(m)
|
|
else :
|
|
f += u'aucune'
|
|
|
|
return f
|
|
|
|
clients_ipsec = None
|
|
def ipsec_ok(machine) :
|
|
"""Indique si une machine est correctement authentifiée"""
|
|
return False
|
|
|
|
def machine_details(machine) :
|
|
"""
|
|
Formatage du détail des propriétés d'une machine
|
|
"""
|
|
f = ''
|
|
f+= coul(u'mid=%s ' % machine.id(),'bleu')
|
|
|
|
# Type de machine
|
|
if isinstance(machine, MachineWifi): a = 'Machine wifi'
|
|
elif isinstance(machine, BorneWifi): a = 'Borne wifi'
|
|
else: a = 'Machine fixe'
|
|
f += coul(a + ' : ', 'gras')
|
|
|
|
f+= "%s " % machine.nom()
|
|
|
|
if machine.rid() != '':
|
|
f+= coul(u'rid=%s '% machine.rid(), 'bleu')
|
|
|
|
f+= "\n"
|
|
|
|
# Alias ?
|
|
alias = machine.alias()
|
|
if alias :
|
|
f += coul(u'Alias : ' ,'gras') + ', '.join(alias)
|
|
f+= '\n'
|
|
|
|
f+= coul(u'IP : ','gras') + "%s\t\t" %machine.ip()
|
|
f+= coul(u'MAC : ','gras') + "%s\n" %machine.mac()
|
|
|
|
if len(machine.sshFingerprint()) > 0 and aff_ssh:
|
|
f += u"\n".join([coul(u'Fingerprint SSH : ', 'gras') + u"%s" % (i) for i in machine.sshFingerprint()])+"\n"
|
|
|
|
# Propriétaire
|
|
f+= coul(u'Propriétaire : ','gras')
|
|
try :
|
|
f += machine.proprio + coul(' (adhérent détruit)', 'jaune')
|
|
a = AssociationCrans()
|
|
except :
|
|
a = machine.proprietaire()
|
|
f += "%s" % a.Nom()
|
|
if a.chbre() in ['EXT', '????']:
|
|
f += ' (%s = %s)' % (a.idn, a.id())
|
|
elif a.chbre() != 'CRA':
|
|
f += " (%s)" % a.chbre()
|
|
else :
|
|
f += coul(u'\t\tPrise : ','gras') + machine.prise()
|
|
f+= '\n'
|
|
|
|
if isinstance(machine, MachineCrans):
|
|
n = machine.nombrePrises()
|
|
if n >= 0:
|
|
f += coul(u'Nombre de prises : ', 'gras')
|
|
f += "%d\n" % n
|
|
|
|
# Adhérent blacklisté ?
|
|
bl = a.blacklist_actif()
|
|
if bl :
|
|
f += coul(u'Restrictions sur adhérent : ','gras')
|
|
f += coul(u', '.join(bl),'rouge')
|
|
f += '\n'
|
|
|
|
# Borne wifi
|
|
if isinstance(machine, BorneWifi):
|
|
f += coul(u'Hotspot : ', 'gras')
|
|
f += machine.hotspot() and 'oui' or 'non'
|
|
position = machine.position()
|
|
if position:
|
|
f += coul(u'\t\t\tCoordonnées : ', 'gras')
|
|
f += u'%s°N, %s°E\n' % position
|
|
else:
|
|
f += '\n'
|
|
|
|
if (machine.prise() != 'N/A'):
|
|
try:
|
|
f += coul(u'VLANs : ', 'gras')
|
|
from hptools import sw_prise
|
|
f += ', '.join(sw_prise(machine.prise()).vlans())
|
|
f += '\n'
|
|
except:
|
|
pass
|
|
|
|
f += coul(u'Puissance : ','gras') + u"%4.d" % int(machine.puissance())
|
|
f += coul(u'\tCanaux : ', 'gras') + machine.canal()
|
|
f += coul(u'\tÉtat : ', 'gras')
|
|
if borne_etat(machine.nom()):
|
|
f += coul(u'borne active', 'vert')
|
|
f += '\n'
|
|
canal_clients = borne_clients_canal(machine.nom())
|
|
clients = canal_clients["mac-rssi"]
|
|
canal = canal_clients["canal"]
|
|
f += coul(u'\t Canal courant : ', 'gras') + u"%d" % canal
|
|
f += "\n"
|
|
# S'il y a des clients, on les liste
|
|
if clients and base:
|
|
f += coul(u'Clients : \n','gras')
|
|
for (client, rssi) in clients:
|
|
# On va chercher le nom correspondant à l'adresse MAC
|
|
res = base.search("mac=%s" % client)['machine']
|
|
authentification=""
|
|
if not res:
|
|
client_nom = '????'
|
|
client_chbre = '????'
|
|
else:
|
|
client_nom = ", ".join(["%s [%s]" % (x.nom().split(".")[0],
|
|
x.proprietaire().Nom()) for x in res])
|
|
# On va regarder si le client est authentifié
|
|
auth_ok = ipsec_ok(x)
|
|
if auth_ok != None:
|
|
if auth_ok:
|
|
authentification = "; IPSec: %s" % OK
|
|
else:
|
|
authentification = "; IPSec: %s" % ERREUR
|
|
client_chbre = " ".join(["%s " % (x.proprietaire().chbre()) for x in res])
|
|
# On va choisir la bonne couleur pour le RSSI
|
|
if rssi > -88:
|
|
coul_rssi = 'vert'
|
|
elif rssi > -93:
|
|
coul_rssi = 'jaune'
|
|
else:
|
|
coul_rssi = 'rouge'
|
|
f += u' %s (%s Chbre : %s) (RSSI: %s%s)\n' % (client, client_nom, client_chbre,
|
|
coul("%d" % rssi, coul_rssi),
|
|
authentification)
|
|
else:
|
|
f += coul(u'borne éteinte','rouge')
|
|
f += '\n'
|
|
if machine.nvram():
|
|
f += coul(u'NVRAM : ', 'gras')
|
|
f += ', '.join(machine.nvram()) + '\n'
|
|
|
|
if aff_ipsec and isinstance(machine, MachineWifi):
|
|
f += coul(u'Clef WiFi : ','gras') + machine.ipsec()
|
|
f += '\n'
|
|
|
|
# Ports spéciaux
|
|
if machine.portTCPin():
|
|
f += coul(u'Ports TCP ouvert ext->machine : ','gras') + ' '.join(machine.portTCPin()) + '\n'
|
|
if machine.portTCPout():
|
|
f += coul(u'Ports TCP ouvert machine->ext : ','gras') + ' '.join(machine.portTCPout()) + '\n'
|
|
if machine.portUDPin():
|
|
f += coul(u'Ports UDP ouvert ext->machine : ','gras') + ' '.join(machine.portUDPin()) + '\n'
|
|
if machine.portUDPout():
|
|
f += coul(u'Ports UDP ouvert machine->ext : ','gras') + ' '.join(machine.portUDPout()) + '\n'
|
|
|
|
# Exemption d'upload
|
|
if machine.exempt() :
|
|
f += coul(u'Upload exempté vers : ','gras') + ', '.join(machine.exempt()) + '\n'
|
|
|
|
f += _blacklist(machine)
|
|
f += _info(machine)
|
|
f += _hist(machine)
|
|
|
|
return f
|
|
|
|
def club_details(club) :
|
|
"""
|
|
Affichage du détail des propriétés d'un club
|
|
"""
|
|
f=''
|
|
# Cid
|
|
f+= coul(u'cid=%s ' % club.id() ,'bleu')
|
|
# Nom
|
|
f += coul(u'Nom : ','gras') + "%s\n" % club.Nom()
|
|
|
|
# responsale
|
|
f += coul(u'Responsable : ','gras') + "%s\n" % club.responsable().Nom()
|
|
|
|
# Imprimeurs
|
|
if len(club.imprimeurs()) > 0:
|
|
f += (coul(u'Imprimeurs : ', 'gras') + "%s\n" % ', '.join(map(lambda x:
|
|
club.search("aid=%s" % x)['adherent'][0].Nom(), club.imprimeurs())))
|
|
|
|
# État administratif
|
|
f += coul(u'État administratif : ','gras')
|
|
jour=1
|
|
if ann_scol not in club.paiement() :
|
|
if not jour : f += ' et '
|
|
f += coul(u"charte %s/%d non signée"% (ann_scol, ann_scol+1 ),'violet')
|
|
jour = 0
|
|
|
|
if jour :
|
|
f += coul(u"à jour",'vert')
|
|
f += '\n'
|
|
|
|
# Chambre + prise
|
|
etat, vlans, cablage = prise_etat(club.chbre())
|
|
f += coul(u'Local : ','gras') + u"%s " % club.local()
|
|
f += u'(%s)' % etat
|
|
f += u'\n'
|
|
f += coul(u'Brassage : ','gras')
|
|
f += cablage
|
|
f += u'\n'
|
|
# VLAN
|
|
if vlans :
|
|
f += coul(u'VLAN : ','gras') + u'%s' % vlans
|
|
f += u'\n'
|
|
|
|
# Paiement
|
|
if club.paiement() :
|
|
f += coul(u'Charte signée pour les années scolaires :','gras')
|
|
g = ''
|
|
for an in club.paiement() : g += " %i-%i" % ( an, an+1 )
|
|
if len(g) > 35 : f += '\n\t'
|
|
f += g
|
|
if 'p' in club.controle(): f += coul(u' (OK)', 'vert')
|
|
f += '\n'
|
|
|
|
login = club.compte()
|
|
if login :
|
|
f += coul(u'Login : ','gras') + login
|
|
alias = club.alias()
|
|
if alias :
|
|
f += coul(u'\tAlias : ','gras') + ', '.join(alias)
|
|
f+= u'\n'
|
|
|
|
# Solde
|
|
solde = club.solde()
|
|
if solde:
|
|
f += coul(u'Solde : ', 'gras')
|
|
if solde < 0:
|
|
f+= coul(str(solde).replace('.', ','), 'rouge')
|
|
else:
|
|
f += str(solde).replace('.', ',')
|
|
f += u" Euros\n"
|
|
|
|
f += _blacklist(club)
|
|
f += _info(club)
|
|
f += _hist(club)
|
|
|
|
# Formatage des machines aussi
|
|
f += coul(u'Machine(s) : ','gras')
|
|
m = club.machines()
|
|
if m :
|
|
f += '\n' + list_machines(m)
|
|
else :
|
|
f += 'aucune'
|
|
|
|
return f
|
|
|
|
###########################################
|
|
# Fonctions annexes de formatage de données
|
|
|
|
def _blacklist(clas):
|
|
""" Formatage blackliste de la classe fournie """
|
|
if limit_aff_blacklist == 0: return ''
|
|
f = u''
|
|
bl = clas.blacklist()
|
|
bl.reverse()
|
|
nb = 0
|
|
for event in bl:
|
|
nb += 1
|
|
if nb > limit_aff_blacklist: break
|
|
if is_actif(event):
|
|
# Colorisation si sanction en cours
|
|
c = 'rouge'
|
|
else :
|
|
c = 'blanc'
|
|
event = event.split('$')
|
|
dates = strftime('%d/%m/%Y %H:%M', localtime(int(event[0])))
|
|
if event[1] == '-':
|
|
dates = u'à partir du %s' % dates
|
|
else:
|
|
dates = u'du %s au ' % dates
|
|
dates += strftime('%d/%m/%Y %H:%M', localtime(int(event[1])))
|
|
f += u"%s\n\t " % coul(u'%s : %s [%s]' % (dates, event[2], event[3]), c)
|
|
|
|
f = f[:-6] # suppression des espaces superflus
|
|
|
|
if len(bl) > limit_aff_blacklist:
|
|
f += ' [...]\n'
|
|
|
|
if f:
|
|
return coul(u'Blackliste : ', 'gras') + f
|
|
else:
|
|
return ''
|
|
|
|
def _info(clas) :
|
|
""" Formatage des remarques de la classe fournie """
|
|
f= u''
|
|
c = clas.info()
|
|
if c :
|
|
f += coul(u'Remarque :\n ' ,'gras')
|
|
f += u'\n '.join(c)
|
|
f += u'\n'
|
|
return f
|
|
|
|
def _hist(clas) :
|
|
""" Formatage de l'historique de la classe fournie """
|
|
if limit_aff_historique==0 : return ''
|
|
f=u''
|
|
h = clas.historique()
|
|
h.reverse()
|
|
if h :
|
|
f += coul(u'Historique : ','gras')
|
|
for i in range(0,limit_aff_historique) :
|
|
try :
|
|
a = h[i] # Produit une erreur si i trop grand
|
|
if i !=0 : f += ' '
|
|
try:
|
|
# on force l'encodage ici sinon il est fait au moment de l'impression a
|
|
# l'ecran et il empeche l'affichage de toutes les infos
|
|
f += u'%s\n' % a
|
|
except Exception, e:
|
|
if debug:
|
|
f += coul(u'*** non affichable [%s] ***\n' % str(e), 'rouge')
|
|
else:
|
|
f += coul(u'*** non affichable ***\n', 'rouge')
|
|
except :
|
|
break
|
|
try :
|
|
if h[i+1] : f += ' [...]\n'
|
|
except :
|
|
None
|
|
|
|
return f
|
|
|
|
def __bases_machines(m) :
|
|
""" Retourne [ type de la machines, blacklist ] """
|
|
#Type
|
|
t = 'inconnu'
|
|
for tp, (start, end) in rid.iteritems():
|
|
if start <= int(m.rid()) <= end:
|
|
t = tp
|
|
break
|
|
|
|
if isinstance(m, BorneWifi):
|
|
t = "borne"
|
|
|
|
# Déconnectée ?
|
|
b = m.blacklist_actif()
|
|
if not b :
|
|
bl = '-'
|
|
elif len(b) == 1 :
|
|
bl = coul(b[0],'rouge')
|
|
else :
|
|
bl = coul(u'cf détails','rouge')
|
|
|
|
return t , bl
|
|
|
|
def borne_etat(borne) :
|
|
"""Renvoie vrai si la borne est up, faux sinon"""
|
|
# On utilise fping, en cas d'erreur, on considere
|
|
# que la borne est down (alors qu'elle peut simplement
|
|
# ne pas exister)
|
|
try:
|
|
retour = os.system("fping -q -c 1 %s > /dev/null 2> /dev/null" % borne)
|
|
return (retour == 0)
|
|
except:
|
|
return False
|
|
|
|
def borne_clients_canal(borne) :
|
|
"""Renvoie la liste des adresses MAC associées à la borne ainsi que le canal.
|
|
|
|
Chaque adresse MAC est en fait contenue dans un couple comprenant
|
|
l'adresse MAC et le RSSI du client associé.
|
|
|
|
On en profite pour renvoyer également le canal en cours de la
|
|
borne. On fait cela dans la même fonction car cela évite de faire
|
|
deux connexions ssh (ce qui est fort coûteux).
|
|
|
|
Au final, on renvoie un dictionnaire
|
|
- mac-rssi: une liste de couples (MAC, RSSI)
|
|
- canal: le canal en cours
|
|
"""
|
|
macs = []
|
|
canal = -1
|
|
return {"canal": canal, "mac-rssi": macs} # Suite à réimplémenter
|
|
# Uniquement possible pour les admins et si on a la clef
|
|
for clef in ["/etc/wifi/ssh/wifi","/usr/scripts/gestion/clef-wifi"]:
|
|
if os.path.isfile(clef) and user_tests.isadm():
|
|
try:
|
|
wl = subprocess.Popen("ssh -o StrictHostKeyChecking=no -i %s root@%s 'cat /tmp/auth-mac.dump ; echo -n \"CANAL \" ; /usr/sbin/nvram get wl0_channel'" % (clef, borne), shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=True)
|
|
wl.stdin.close()
|
|
for line in wl.stdout.readlines():
|
|
print 'coucou'
|
|
print line
|
|
# Chaque ligne est de la forme
|
|
# 00:11:22:33:44:55 -20
|
|
line = line.strip().split()
|
|
if line[0] == "CANAL":
|
|
canal = int(line[-1])
|
|
else:
|
|
macs.append((line[0].strip(), int(line[1].strip())))
|
|
except:
|
|
pass
|
|
break # Pas la peine d'essayer une autre clef
|
|
return {"canal": canal, "mac-rssi": macs}
|
|
|
|
def prise_etat(chbre) :
|
|
"""
|
|
Retoune un triplet contenant l'état de la prise associée à la [chbre],
|
|
les VLANs activés ainsi que l'état du brassage.
|
|
"""
|
|
f = u''
|
|
vlans = u''
|
|
cablage = u''
|
|
try:
|
|
# On met aussi l'état
|
|
from hptools import sw_chbre, ConversationError
|
|
import annuaires_pg
|
|
prise = sw_chbre(chbre)
|
|
vlans += ', '.join(prise.vlans())
|
|
if annuaires_pg.is_crans(chbre[0],chbre[1:]) :
|
|
cablage += coul(u'Cr@ns','bleu')
|
|
else :
|
|
cablage += coul(u'CROUS','jaune')
|
|
if annuaires_pg.is_connected(chbre[0],chbre[1:]) :
|
|
cablage += u'.'
|
|
else :
|
|
cablage += u', ' + coul(u'cablage non effectué !','rouge')
|
|
f += u'prise %s' % prise.prise_brute
|
|
rows, cols = get_screen_size()
|
|
if prise.is_up() :
|
|
f += u', ' + coul(u'machine branchée','vert')
|
|
reste_cols = cols - 45
|
|
f+=', '
|
|
macs = prise.show_prise_mac()
|
|
if len(macs) == 0:
|
|
if reste_cols < 20 :
|
|
# Faut aller à la ligne
|
|
f += u'\n '
|
|
f += coul(u'aucune MAC détectée', 'jaune')
|
|
else:
|
|
if len(macs) == 1 and reste_cols > 25 :
|
|
# Une seule mac et on a assez de place
|
|
f += u"MAC: %s" % macs[0]
|
|
else :
|
|
# On va à la ligne
|
|
# Combien d'adresses MAC peut-on mettre par ligne ?
|
|
# Une adresse MAC =~ 20 caracteres
|
|
cols -= 17 # On met 15espaces devant chaque ligne
|
|
parligne = int(cols/20)
|
|
count = 0
|
|
while len(macs) > 0:
|
|
if count % parligne == 0:
|
|
f += u'\n MACs: '
|
|
else:
|
|
f += u', '
|
|
f += u"%s" % macs.pop()
|
|
count += 1
|
|
elif not prise.is_enable() :
|
|
f+= u', ' + coul(u'prise désactivée','rouge')
|
|
else :
|
|
f+= u', activée, lien non détecté'
|
|
try:
|
|
import annuaires_pg
|
|
extra_info = annuaires_pg.chbre_commentaire(chbre[0],chbre[1:]).decode('utf-8')
|
|
if extra_info:
|
|
f += u'\n' + ' '*10 + extra_info
|
|
except ValueError:
|
|
pass
|
|
except ConversationError, r:
|
|
# Switch non manageable ou down
|
|
f += ', '
|
|
f+= {'Unknown host (No such file or directory)' :
|
|
u'switch non manageable',
|
|
'Failure in sendto (Operation not permitted)' :
|
|
u'infos prise non dispo : filtre vers adm par fw',
|
|
'sh: line 1: command not found' :
|
|
u'infos prise non dispo depuis cette machine'
|
|
}.get(r.args[0],r.args[0])
|
|
except ValueError, r :
|
|
f = r
|
|
except :
|
|
f = u'infos prise non dispo : erreur interne'
|
|
return f, vlans, cablage
|
|
|
|
##############################################################################
|
|
## Partie dévolue au système de recherche
|
|
|
|
def __usage_brief(err='') :
|
|
""" Message d'erreur """
|
|
if err : cprint(err,'gras')
|
|
cprint(u"Pour obtenir de l'aide sur l'utilisation de ce programme utilisez l'option -h")
|
|
sys.exit(2)
|
|
|
|
def __usage() :
|
|
""" Comment ca marche ? """
|
|
liste = []
|
|
accu = ""
|
|
longueur = 0
|
|
|
|
# Champs automatiques
|
|
champs = []
|
|
for c in base.auto_search_champs.values():
|
|
for champ in c:
|
|
if champ not in champs:
|
|
champs.append(champ)
|
|
for champ in champs:
|
|
coul_champ = coul(champ, "bleu")
|
|
if accu == "":
|
|
accu = coul_champ
|
|
longueur = len(champ)
|
|
elif longueur + 2 + len(champ) < 80:
|
|
longueur += 2 + len(champ)
|
|
accu += ", " + coul_champ
|
|
else:
|
|
liste.append(accu)
|
|
accu = coul_champ
|
|
longueur = len(champ)
|
|
|
|
# Champs manuels
|
|
champs = []
|
|
for c in base.non_auto_search_champs.values():
|
|
for champ in c:
|
|
if champ not in champs:
|
|
champs.append(champ)
|
|
for champ in champs:
|
|
if longueur + 2 + len(champ) < 80:
|
|
longueur += 2 + len(champ)
|
|
accu += ", " + champ
|
|
else:
|
|
liste.append(accu)
|
|
accu = champ
|
|
longueur = len(champ)
|
|
|
|
# Dernière ligne
|
|
liste.append(accu)
|
|
|
|
cprint(__doc__ % { 'prog': sys.argv[0].split('/')[-1].split('.')[0],
|
|
'champs_rech': '\n'.join(liste),
|
|
'limit_aff_details': limit_aff_details,
|
|
'limit_aff_historique': limit_aff_historique,
|
|
'limit_aff_blacklist': limit_aff_blacklist })
|
|
sys.exit(0)
|
|
|
|
def __recherche() :
|
|
"""
|
|
Recherche et affichage des résultats à partir des options founies (sys.argv)
|
|
"""
|
|
global aff_ipsec, aff_ssh, limit_aff_details, limit_aff_historique, limit_aff_blacklist, debug
|
|
|
|
# Récupération des options
|
|
if len(sys.argv) == 1 :
|
|
# Pas d'option fournie
|
|
__usage_brief()
|
|
|
|
try :
|
|
options, arg = getopt.getopt(sys.argv[1:], 'hamcstbil:L:d:', [ 'debug', 'help', 'adherent', 'machine', 'club' , 'tech', 'bornes', 'limit=', 'limit-historique=', 'limit-blacklist=', 'ipsec', 'crans', 'ssh' ])
|
|
except getopt.error, msg :
|
|
__usage_brief(unicode(msg))
|
|
|
|
|
|
# Traitement des options
|
|
only_adh=0
|
|
only_mac=0
|
|
only_club=0
|
|
only_bornes=0
|
|
only_crans=0
|
|
mtech = 0
|
|
|
|
for opt, val in options :
|
|
if opt == '-h' or opt=='--help' :
|
|
__usage()
|
|
elif opt =='--debug' :
|
|
# Mode debug
|
|
debug = 1
|
|
elif opt == '-l' or opt =='--limit':
|
|
# Passage mode condensé, mode détaillé
|
|
try : limit_aff_details = int(val)
|
|
except :
|
|
__usage_brief(u'Valeur du paramètre %s incorrect (doit être un entier positif)' % opt)
|
|
elif opt == '-L' or opt =='--limit-historique':
|
|
# Limitation du nombre de lignes d'historique
|
|
try : limit_aff_historique = int(val)
|
|
except :
|
|
__usage_brief(u'Valeur du paramètre %s incorrect (doit être un entier positif)' % opt)
|
|
elif opt == '-d' or opt =='--limit-blacklist':
|
|
# Limitation du nombre de lignes d'historique
|
|
try : limit_aff_blacklist = int(val)
|
|
except :
|
|
__usage_brief(u'Valeur du paramètre %s incorrect (doit être un entier positif)' % opt)
|
|
elif opt in [ '-a', '--adherent' ] :
|
|
only_adh = 1
|
|
cprint(u"Affichage limité aux adhérents.")
|
|
elif opt in [ '-m', '--machine' ] :
|
|
only_mac = 1
|
|
cprint(u"Affichage limité aux machines.")
|
|
elif opt in [ '-c', '--club' ] :
|
|
only_club = 1
|
|
cprint(u"Affichage limité aux clubs.")
|
|
elif opt == '--crans' :
|
|
only_crans = 1
|
|
mtech = 1
|
|
cprint(u"Affichage limité aux machines du crans.")
|
|
elif opt in [ '-b', '--bornes' ] :
|
|
only_bornes = 1
|
|
cprint(u"Affichage limité aux bornes wifi.")
|
|
# On va tenter de limiter un peu la recherche
|
|
if not arg :
|
|
# Recherche initiale sans critère
|
|
arg = [ 'canal=*&host=*.crans.org']
|
|
elif arg[0].find('=')!=-1 :
|
|
# Recherche avec critères
|
|
arg += [ '&canal=*' ]
|
|
elif opt in [ '-t', '--tech' ] :
|
|
# Format affichage des machines
|
|
mtech = 1
|
|
elif opt in [ '-i', '--ipsec' ] :
|
|
# Affichage des clefs ipsec
|
|
aff_ipsec = 1
|
|
elif opt in [ '-s', '--ssh' ]:
|
|
aff_ssh = 1
|
|
|
|
if only_adh + only_mac + only_club + only_bornes > 1 :
|
|
__usage_brief(u'Options utilisées incompatibles')
|
|
|
|
arg = ' '.join(arg)
|
|
# Cas particulier de recherche sur prise
|
|
if arg.count('=') == 1 and arg.split('=')[0] == 'prise' :
|
|
prise = arg.split('=')[1]
|
|
# Récupération de la chambre
|
|
try:
|
|
from annuaires_pg import reverse
|
|
chbre = reverse(prise[0].lower(), prise[1:])
|
|
except KeyError:
|
|
chbre=None
|
|
|
|
if chbre:
|
|
if len(chbre) != 1 :
|
|
cprint(u"Prise correspondante à plusieurs chambres %s" % ' '.join(chbre))
|
|
return
|
|
# On fait la recherche sur la chambre
|
|
chbre= prise[0] + chbre[0]
|
|
#cprint(u"Recherche sur chambre %s" % chbre)
|
|
arg = u'chbre=%s' % chbre
|
|
# sinon on ne fait rien et on recherche sur le champ prise
|
|
|
|
try:
|
|
if only_crans :
|
|
res = { 'machine' : AssociationCrans().machines() , 'adherent' : [] , 'club' : [] }
|
|
else :
|
|
if not arg :
|
|
# Pas de chaine de recherche fournie
|
|
__usage_brief(u'Chaine de recherche incorrecte.')
|
|
res = base.search(arg)
|
|
except ValueError, c :
|
|
__usage_brief(c.args[0])
|
|
|
|
# Traitement du résultat
|
|
if not res['adherent'] and not res['machine'] and not res['club']:
|
|
# Pas de résultat dans la base
|
|
# Recherche sur chambre ?
|
|
if arg.count('=') == 1 and arg.split('=')[0] == 'chbre' :
|
|
# Affichage des infos de la chambre
|
|
chbre = arg.split('=')[1]
|
|
cprint(u"Chambre %s inoccupée ou invalide (%s)" % (chbre,prise_etat(chbre)[0]))
|
|
else :
|
|
cprint(u"Aucun résultat trouvé.")
|
|
sys.exit(3)
|
|
# L'affichage souhaité a été précisé ?
|
|
elif only_bornes :
|
|
if not res['machine'] :
|
|
cprint(u'Aucun résultat à afficher')
|
|
sys.exit(4)
|
|
else :
|
|
if len(res['machine']) > limit_aff_details :
|
|
cprint(list_bornes(res['machine']))
|
|
else :
|
|
aff(res['machine'])
|
|
elif only_adh :
|
|
if res['adherent'] : aff(res['adherent'])
|
|
elif res['machine'] :
|
|
to_aff=[]
|
|
traite =[]
|
|
for m in res['machine'] :
|
|
a = m.proprietaire()
|
|
if a.idn != 'aid' or a.id() in traite : continue
|
|
traite.append(a.id())
|
|
to_aff.append(m.proprietaire())
|
|
if not(to_aff) :
|
|
cprint(u'Aucun résultat à afficher')
|
|
sys.exit(4)
|
|
aff(to_aff)
|
|
elif res['club'] :
|
|
cprint(u'Aucun résultat à afficher')
|
|
sys.exit(4)
|
|
elif only_mac :
|
|
if res['machine'] : aff(res['machine'],mtech)
|
|
else :
|
|
to_aff = []
|
|
for a in res['adherent'] + res['club'] :
|
|
to_aff += a.machines()
|
|
aff(to_aff)
|
|
elif only_club :
|
|
if res['club'] : aff(res['club'])
|
|
elif res['machine'] :
|
|
to_aff=[]
|
|
traite =[]
|
|
for m in res['machine'] :
|
|
a = m.proprietaire()
|
|
if a.idn != 'cid' or a.id() in traite : continue
|
|
if a.id() in traite : continue
|
|
traite.append(a.id())
|
|
to_aff.append(m.proprietaire())
|
|
if not(to_aff) :
|
|
cprint(u'Aucun résultat à afficher')
|
|
sys.exit(4)
|
|
aff(to_aff)
|
|
elif res['adherent'] :
|
|
cprint(u'Aucun résultat à afficher')
|
|
sys.exit(4)
|
|
# Non : on affiche tout.
|
|
else :
|
|
if res['adherent'] :
|
|
cprint(u"Résultats trouvés parmi les adhérents :", 'cyan')
|
|
aff(res['adherent'])
|
|
if res['machine'] :
|
|
cprint(u"Résultats trouvés parmi les machines :", 'cyan')
|
|
aff(res['machine'],mtech)
|
|
if res['club']:
|
|
cprint(u"Résultats trouvés parmi les clubs :", 'cyan')
|
|
aff(res['club'])
|
|
|
|
if __name__ == '__main__' :
|
|
global debug
|
|
debug = 0
|
|
|
|
import sys, getopt
|
|
|
|
base = crans_ldap()
|
|
|
|
try :
|
|
__recherche()
|
|
except KeyboardInterrupt :
|
|
cprint(u"Recherche interrompue par l'utilisateur.")
|
|
sys.exit(255)
|
|
except SystemExit, c :
|
|
# Fin
|
|
sys.exit(c)
|
|
except :
|
|
cprint(u"""Une erreur fatale s'est produite durant l'exécution.
|
|
Pour l'amélioration de ce programme merci de prévenir nounou en spécifiant la
|
|
marche à suivre pour reproduire cette erreur.""")
|
|
if debug :
|
|
cprint('-'*40)
|
|
cprint(u'Détails techniques :')
|
|
import traceback
|
|
# On veut le traceback sur la sortie standard
|
|
sys.stderr = sys.stdout
|
|
traceback.print_exc()
|
|
sys.exit(1)
|