[ldap_crans.py] stop doing drugs
Ignore-this: 7bf92831b6ce1ec3bfc77b63fea84f9b darcs-hash:20090929232441-ffbb2-460922e5b3d9b77c114ea159be21e36985aef064.gz
This commit is contained in:
Nicolas Dandrimont
parent
fd5cca07f2
commit
80898c00d4
2 changed files with 57 additions and 191 deletions
|
|
@ -228,8 +228,7 @@ def format_mac(mac):
|
|||
### Définition des classes
|
||||
|
||||
class Service:
|
||||
u"Définit un service à redémarrer"
|
||||
|
||||
u""" Définit un service à redémarrer """
|
||||
def __init__(self, nom, args=[], start=[]):
|
||||
"""
|
||||
Nom du service
|
||||
|
|
@ -257,7 +256,7 @@ class Service:
|
|||
def __str__(self):
|
||||
return self.__unicode__().encode("utf-8", "ignore")
|
||||
|
||||
class CransLdap(dict):
|
||||
class CransLdap:
|
||||
"""
|
||||
Classe de connexion à la base LDAP du crans.
|
||||
"""
|
||||
|
|
@ -330,31 +329,17 @@ class CransLdap(dict):
|
|||
'borneWifi': 2,
|
||||
'facture': 2}
|
||||
|
||||
def __init__(self, **kw):
|
||||
"""Fonction d'initialisation.
|
||||
Marche en 2 temps: initialise la connexion ldap, puis initialise
|
||||
le dictionnaire."""
|
||||
self.__obj_init__(**kw)
|
||||
self.__dict_init__(**kw)
|
||||
|
||||
def __obj_init__(self, readonly = False, conn = None, **kw):
|
||||
"""Initialisation de la connexion à la base LDAP.
|
||||
Cette connexion sera réutilisée pour tous les objets créés
|
||||
depuis cet objet (notamment grâce à la méthode make)"""
|
||||
if not self.conn:
|
||||
self.conn = conn
|
||||
if not self.conn:
|
||||
self.connect(readonly)
|
||||
def __init__(self, readonly=False):
|
||||
self.connect(readonly)
|
||||
|
||||
def __del__(self):
|
||||
"Destruction de l'objet, et surtout des locks."
|
||||
# Destruction des locks résiduels
|
||||
if hasattr(self, '_locks'):
|
||||
for lock in self._locks:
|
||||
self.remove_lock(lock)
|
||||
|
||||
def connect(self, readonly=False):
|
||||
u"Initialisation la connexion vers le serveur LDAP"
|
||||
u""" Initialisation la connexion vers le serveur LDAP """
|
||||
if readonly:
|
||||
self.conn = ldap.initialize(ro_uri)
|
||||
return
|
||||
|
|
@ -374,8 +359,9 @@ class CransLdap(dict):
|
|||
time.sleep(0.3)
|
||||
|
||||
def exist(self, arg):
|
||||
"""Vérifie l'existence d'une entrée dans la base et que cette entrée
|
||||
n'appartient pas à l'objet en cours.
|
||||
u"""
|
||||
Vérifie l'existence d'une entrée dans la base et que cette
|
||||
entrée n'appartient pas à l'objet en cours.
|
||||
|
||||
La méthode prend en compte les locks.
|
||||
|
||||
|
|
@ -607,12 +593,12 @@ class CransLdap(dict):
|
|||
# On récupère la bonne classe
|
||||
nom_classe = (entry[1].get('objectClass') or ['none'])[0]
|
||||
nom_classe = nom_classe[0].upper() + nom_classe[1:]
|
||||
#try:
|
||||
classe = eval(nom_classe)
|
||||
try:
|
||||
classe = eval(nom_classe)
|
||||
# On crée l'objet
|
||||
return classe(data= entry, mode= mode, conn= self.conn)
|
||||
#except:
|
||||
# raise ValueError(u"Impossible de créer l'objet %s" % nom_classe)
|
||||
return classe(entry, mode, self.conn)
|
||||
except:
|
||||
raise ValueError(u"Impossible de créer l'objet %s" % nom_classe)
|
||||
|
||||
|
||||
def search(self, expression, mode=''):
|
||||
|
|
@ -894,16 +880,6 @@ class CransLdap(dict):
|
|||
|
||||
return self.__machines
|
||||
|
||||
########################################################################
|
||||
# Méthodes pour fournir une interface proche d'un dictionnaire
|
||||
def __dict_init__(self, dico= {}, **kw):
|
||||
for lbl, value in dico.items(): dict.__setitem__(self, lbl, value)
|
||||
def init_locks(self, locks): self._locks = locks
|
||||
def copy(self):
|
||||
new = self.__class__(conn = self.conn, dico = self)
|
||||
new._locks = self._locks
|
||||
return new
|
||||
|
||||
#############################################################################
|
||||
|
||||
class BaseClasseCrans(CransLdap):
|
||||
|
|
@ -1331,7 +1307,7 @@ class BaseClasseCrans(CransLdap):
|
|||
class BaseProprietaire(BaseClasseCrans):
|
||||
u""" Méthodes de bases pour les classes Adherent et Club """
|
||||
|
||||
def __obj_init__(self, mode='', conn= None, **kw):
|
||||
def __init__(self, data=(), mode='', conn=None):
|
||||
u"""
|
||||
Si data est fourni initialise l'adhérent avec les valeurs données
|
||||
Format de data : tuple comme retourné par une recherche dans la base ldap:
|
||||
|
|
@ -1343,16 +1319,14 @@ class BaseProprietaire(BaseClasseCrans):
|
|||
|
||||
conn est une instance de la classe de connexion à la base LDAP
|
||||
"""
|
||||
self.conn = conn
|
||||
if not self.conn:
|
||||
self.connect()
|
||||
|
||||
# Initialisation de la connexion à zelda
|
||||
BaseClasseCrans.__obj_init__(self, conn = conn)
|
||||
|
||||
data = kw.get('data', ())
|
||||
if type(data) != tuple:
|
||||
raise TypeError
|
||||
|
||||
self.modifs = {}
|
||||
data = kw.get('data', ())
|
||||
if data:
|
||||
self.dn = data[0]
|
||||
if mode == 'w':
|
||||
|
|
@ -1373,7 +1347,6 @@ class BaseProprietaire(BaseClasseCrans):
|
|||
self._init_data = {}
|
||||
self._modifiable = 'w'
|
||||
|
||||
|
||||
def chsh(self, new=None):
|
||||
u""" Retourne ou change le shell de l'adhérent """
|
||||
if new == None:
|
||||
|
|
@ -1838,34 +1811,6 @@ class BaseProprietaire(BaseClasseCrans):
|
|||
|
||||
return self._data[champ]
|
||||
|
||||
########################################################################
|
||||
# définition des méthodes de dictionnaire
|
||||
def __setitem__(self, lbl, value):
|
||||
# on exécute la parente
|
||||
BaseClasseCrans.__setitem__(self, lbl, value)
|
||||
|
||||
# on fait des trucs sur les labels qui nous intéressent
|
||||
if lbl in ['+p', '+c']:
|
||||
if value == True: self.controle(lbl)
|
||||
elif value == False: self.controle('-' + lbl[1])
|
||||
else: raise ValueError(lbl + u'doit être True ou False')
|
||||
elif lbl == 'shell': self.chsh(value)
|
||||
elif lbl == 'alias': self.alias(value)
|
||||
elif lbl == 'greylist': self.contourneGreylist(value)
|
||||
else: pass
|
||||
|
||||
def __dict_init__(self, **kw):
|
||||
dict.__setitem__(self, 'solde', self.solde())
|
||||
dict.__setitem__(self, 'controle', self.controle())
|
||||
|
||||
def copy(self):
|
||||
new = CransLdap.copy(self)
|
||||
new._init_data = self._init_data
|
||||
new._data = self._data
|
||||
new.modifs = self.modifs
|
||||
new._modifiable = self._modifiable
|
||||
return new
|
||||
|
||||
#############################################################################
|
||||
|
||||
class Adherent(BaseProprietaire):
|
||||
|
|
@ -2459,49 +2404,6 @@ class Adherent(BaseProprietaire):
|
|||
def is_nounou( self ):
|
||||
return u"Nounou" in self.droits()
|
||||
|
||||
##############################################################
|
||||
# définition de __setitem__
|
||||
def __setitem__(self, lbl, value):
|
||||
# on exécute la parente
|
||||
BaseProprietaire.__setitem__(self, lbl, value)
|
||||
|
||||
# on fait les affectations
|
||||
if lbl == 'nom': self.nom(value)
|
||||
elif lbl == 'prenom': self.prenom(value)
|
||||
elif lbl == 'tel': self.tel(value)
|
||||
elif lbl == 'chbre': self.chbre(value)
|
||||
elif re.match(r'addr\d+', lbl):
|
||||
addr = self.adresse()
|
||||
addr[int(lbl[4]) + 1] = value
|
||||
self.adresse(addr)
|
||||
elif lbl == 'mail': self.email(value)
|
||||
elif lbl == 'chartema': self.charteMA(value)
|
||||
elif lbl == 'payant': self.adherentPayant(value)
|
||||
elif re.match(r'etud\d+', lbl):
|
||||
etud = [self.etudes(i) for i in range(3)]
|
||||
etud[int(lbl[4]) - 1] = value
|
||||
self.etudes(etud)
|
||||
elif lbl == 'carte':
|
||||
if value == True: self.carteEtudiant(ann_scol)
|
||||
elif value == False: self.carteEtudiant(-ann_scol)
|
||||
else: raise ValueError(u"carte doit être True ou False")
|
||||
elif lbl == 'compte': self.compte(value)
|
||||
elif re.match('droits_.*', lbl):
|
||||
if value == True: self.droits(droits.append(value[7:]))
|
||||
elif value == False: self.droit(droits.remove(value[7:]))
|
||||
else: raise ValueError(u"les droits_* doivent être True ou False")
|
||||
else: pass
|
||||
|
||||
def __dict_init__(self, **kw):
|
||||
BaseProprietaire.__dict_init__(self, **kw)
|
||||
dict.__setitem__(self, 'nom', self.nom())
|
||||
dict.__setitem__(self, 'prenom', self.prenom())
|
||||
dict.__setitem__(self, 'chbre', self.chbre())
|
||||
dict.__setitem__(self, 'mail', self.email())
|
||||
dict.__setitem__(self, 'payant', self.adherentPayant())
|
||||
for i in range(3): dict.__setitem__(self, 'etud%d'% (i+1), self.etudes(i))
|
||||
dict.__setitem__(self, 'droits', self.droits())
|
||||
dict.__setitem__(self, 'tel', self.tel())
|
||||
|
||||
class Club(BaseProprietaire):
|
||||
u""" Classe de définition d'un club """
|
||||
|
|
@ -2655,25 +2557,15 @@ class Club(BaseProprietaire):
|
|||
u""" Retourne l'adresse mail du responsable """
|
||||
return self.responsable().email()
|
||||
|
||||
########################################################################
|
||||
# Définition de l'initilisation du dico
|
||||
def __dict_init__(self, **kw):
|
||||
BaseProprietaire.__dict_init__(self, **kw)
|
||||
dict.__setitem__(self, 'nom', self.Nom())
|
||||
dict.__setitem__(self, 'chbre', self.chbre())
|
||||
dict.__setitem__(self, 'email', self.email())
|
||||
if self.compte(): dict.__setitem__(self, 'compte', self.compte())
|
||||
dict.__setitem__(self, 'responsable', self.responsable())
|
||||
|
||||
class Machine(BaseClasseCrans):
|
||||
u""" Classe de définition d'une machine """
|
||||
idn = 'mid'
|
||||
filtre_idn = '(|(objectClass=machineFixe)(objectClass=machineWifi)'
|
||||
filtre_idn += '(objectClass=machineCrans)(objectClass=borneWifi))'
|
||||
|
||||
def __obj_init__(self, data =(), mode='', conn=None, **kw):
|
||||
def __init__(self, parent_or_tuple, mode='', conn=None):
|
||||
u"""
|
||||
data est :
|
||||
parent_or_tuple est :
|
||||
* soit une instance d'une classe pouvant posséder une machine
|
||||
(Adherent, Club ou AssociationCrans), la nouvelle machine lui
|
||||
sera alors associée.
|
||||
|
|
@ -2687,19 +2579,20 @@ class Machine(BaseClasseCrans):
|
|||
|
||||
conn est une instance de la classe de connexion à la base LDAP
|
||||
"""
|
||||
|
||||
# Initialisation de la connexion
|
||||
BaseClasseCrans.__obj_init__(self, conn = conn)
|
||||
|
||||
# Définition de l'objectClass LDAP à partir du nom de la classe Python
|
||||
self.objectClass = str(self.__class__).split('.')[-1]
|
||||
self.objectClass = self.objectClass[0].lower() + self.objectClass[1:]
|
||||
|
||||
# Initialisation de la connexion
|
||||
self.conn = conn
|
||||
if not self.conn:
|
||||
self.connect()
|
||||
|
||||
self.modifs = {}
|
||||
t = data.__class__
|
||||
t = parent_or_tuple.__class__
|
||||
if t == tuple:
|
||||
# Initialisation avec données fournies
|
||||
self.dn = data[0]
|
||||
self.dn = parent_or_tuple[0]
|
||||
if mode == 'w':
|
||||
try:
|
||||
self.lock(self.idn, self.id())
|
||||
|
|
@ -2709,16 +2602,16 @@ class Machine(BaseClasseCrans):
|
|||
else:
|
||||
self._modifiable = 0
|
||||
# Utile pour construire l'instruction LDAP de modif
|
||||
self._init_data = data[1].copy()
|
||||
self._data = data[1]
|
||||
self._init_data = parent_or_tuple[1].copy()
|
||||
self._data = parent_or_tuple[1]
|
||||
|
||||
# Propriéraire inconnu mais ce n'est pas grave
|
||||
self.__proprietaire = None
|
||||
|
||||
elif t in [Adherent, Club, AssociationCrans] and mode != 'w':
|
||||
# Machine vide
|
||||
self.__proprietaire = data
|
||||
self.dn = data.dn
|
||||
self.__proprietaire = parent_or_tuple
|
||||
self.dn = parent_or_tuple.dn
|
||||
self._data = {'objectClass': [self.objectClass]}
|
||||
self._init_data = {}
|
||||
self._modifiable = 'w'
|
||||
|
|
@ -3025,13 +2918,11 @@ Contactez nounou si la MAC est bien celle d'une carte.""", 3)
|
|||
if not self.__proprietaire:
|
||||
res = self.conn.search_s(','.join(self.dn.split(',')[1:]), 0)
|
||||
if 'adherent' in res[0][1]['objectClass']:
|
||||
self.__proprietaire = \
|
||||
Adherent(data = res[0], mode = self._modifiable, conn = self.conn)
|
||||
self.__proprietaire = Adherent(res[0], self._modifiable, self.conn)
|
||||
elif 'club' in res[0][1]['objectClass']:
|
||||
self.__proprietaire = \
|
||||
Club(data = res[0], mode = self._modifiable, conn = self.conn)
|
||||
self.__proprietaire = Club(res[0], self._modifiable, self.conn)
|
||||
else:
|
||||
self.__proprietaire = AssociationCrans(conn = self.conn)
|
||||
self.__proprietaire = AssociationCrans(self.conn)
|
||||
|
||||
return self.__proprietaire
|
||||
|
||||
|
|
@ -3192,46 +3083,19 @@ Contactez nounou si la MAC est bien celle d'une carte.""", 3)
|
|||
u"""Retourne un hash de l'objet Machine"""
|
||||
return hash(self.nom())
|
||||
|
||||
################################################################
|
||||
# définintion de __setitem__
|
||||
def __setitem__(self, lbl, value):
|
||||
CransLdap.__setitem__(self, lbl, value)
|
||||
|
||||
if lbl == 'mac': self.mac(value)
|
||||
elif lbl == 'host': self.nom(value)
|
||||
elif lbl == 'prise': self.prise(value)
|
||||
elif lbl == 'alias': self.alias(value)
|
||||
elif lbl == 'ip': self.alias(value)
|
||||
elif lbl == 'exempt': self.exempt(value)
|
||||
# elif lbl == 'proprio':
|
||||
# if re.match(r'\([a-zA-Z]=\d+\)', value):
|
||||
# proprio = self.search(value)['club'][0]
|
||||
# else:
|
||||
# proprio = self.search('(aid=%s)' % value)['adherent'][0]
|
||||
# self.proprietaire(proprio)
|
||||
|
||||
def __dict_init__(self, **kw):
|
||||
BaseClasseCrans.__dict_init__(self, **kw)
|
||||
dict.__setitem__(self, 'mac', self.mac())
|
||||
dict.__setitem__(self, 'host', self.nom())
|
||||
dict.__setitem__(self, 'prise', self.prise())
|
||||
dict.__setitem__(self, 'alias', self.alias())
|
||||
dict.__setitem__(self, 'ip', self.ip())
|
||||
dict.__setitem__(self, 'proprietaire', self.proprietaire())
|
||||
|
||||
class MachineFixe(Machine):
|
||||
u""" Classe de définition d'une machine fixe """
|
||||
|
||||
def __obj_init__(self, typ='fixe', **kw):
|
||||
Machine.__obj_init__(self, typ = typ, **kw)
|
||||
def __init__(self, parent_or_tuple, typ='fixe', conn=None):
|
||||
Machine.__init__(self, parent_or_tuple, typ, conn)
|
||||
|
||||
|
||||
class MachineWifi(Machine):
|
||||
u""" Classe de définition d'une machine wifi """
|
||||
|
||||
def __obj_init__(self, typ='wifi', **kw):
|
||||
Machine.__obj_init__(self, typ=typ, **kw)
|
||||
if not isinstance(kw.get('data', None), tuple):
|
||||
def __init__(self, parent_or_tuple, typ='wifi', conn=None):
|
||||
Machine.__init__(self, parent_or_tuple, typ, conn)
|
||||
if not isinstance(parent_or_tuple, tuple):
|
||||
# Initialisaton d'une nouvelle machine wifi
|
||||
self.ipsec(True)
|
||||
|
||||
|
|
@ -3258,8 +3122,8 @@ class MachineWifi(Machine):
|
|||
class MachineCrans(Machine):
|
||||
u""" Classe de définition d'une machine du Crans """
|
||||
|
||||
def __obj_init__(self, typ='fixe', **kw):
|
||||
Machine.__obj_init__(self, typ, **kw)
|
||||
def __init__(self, parent_or_tuple, typ='fixe', conn=None):
|
||||
Machine.__init__(self, parent_or_tuple, typ, conn)
|
||||
|
||||
def nombrePrises(self, new=None):
|
||||
u""" Nombre de prises, pour les switchs """
|
||||
|
|
@ -3282,9 +3146,9 @@ class MachineCrans(Machine):
|
|||
class BorneWifi(Machine):
|
||||
u"""Classe de définition d'une borne wifi"""
|
||||
|
||||
def __obj_init__(self, typ='borne', **kw):
|
||||
Machine.__obj_init__(self, typ=typ, **kw)
|
||||
if not isinstance(kw.get('data', None), tuple):
|
||||
def __init__(self, parent_or_tuple, typ='borne', conn=None):
|
||||
Machine.__init__(self, parent_or_tuple, typ, conn)
|
||||
if not isinstance(parent_or_tuple, tuple):
|
||||
# Initialisaton d'une nouvelle borne wifi
|
||||
self._data['canal'] = ['2047']
|
||||
self._data['puissance'] = ['60']
|
||||
|
|
@ -3458,7 +3322,7 @@ class Facture(BaseClasseCrans):
|
|||
idn = 'fid'
|
||||
filtre_idn = '(objectClass=facture)'
|
||||
|
||||
def __obj_init__(self, mode='', **kw):
|
||||
def __init__(self, parent_or_tuple, mode='', conn=None):
|
||||
u"""
|
||||
parent_or_tuple est :
|
||||
* soit une instance d'une classe pouvant posséder une facture
|
||||
|
|
@ -3473,11 +3337,13 @@ class Facture(BaseClasseCrans):
|
|||
|
||||
conn est une instance de la classe de connexion à la base LDAP
|
||||
"""
|
||||
|
||||
# Initialisation de la connexion
|
||||
BaseClasseCrans.__obj_init__(self, conn= conn, **kw)
|
||||
self.conn = conn
|
||||
if not self.conn:
|
||||
self.connect()
|
||||
|
||||
self.modifs = {}
|
||||
parent_or_tuple = kw.get('data', None)
|
||||
t = parent_or_tuple.__class__
|
||||
if t == tuple:
|
||||
# Initialisation avec données fournies
|
||||
|
|
@ -3534,11 +3400,9 @@ class Facture(BaseClasseCrans):
|
|||
if not self.__proprietaire:
|
||||
res = self.conn.search_s(','.join(self.dn.split(',')[1:]), 0)
|
||||
if 'adherent' in res[0][1]['objectClass']:
|
||||
self.__proprietaire = \
|
||||
Adherent(data = res[0], mode = self._modifiable, conn = self.conn)
|
||||
self.__proprietaire = Adherent(res[0], self._modifiable, self.conn)
|
||||
elif 'club' in res[0][1]['objectClass']:
|
||||
self.__proprietaire = \
|
||||
Club(data = res[0], mode = self._modifiable, conn = self.conn)
|
||||
self.__proprietaire = Club(res[0], self._modifiable, self.conn)
|
||||
else:
|
||||
raise ValueError, u'Propriétaire inconnu'
|
||||
|
||||
|
|
@ -3786,8 +3650,10 @@ class Facture(BaseClasseCrans):
|
|||
class _FakeProprio(CransLdap):
|
||||
u"""Définitions de base d'un propriétaire virtuel"""
|
||||
idn = ''
|
||||
def __obj_init__(self, conn=None):
|
||||
CransLdap.__obj_init__(self, conn = conn)
|
||||
def __init__(self, conn=None):
|
||||
self.conn = conn
|
||||
if not self.conn:
|
||||
self.connect()
|
||||
self.dn = self.base_dn
|
||||
def id(self):
|
||||
return ''
|
||||
|
|
@ -3810,8 +3676,8 @@ class _FakeProprio(CransLdap):
|
|||
|
||||
class AssociationCrans(_FakeProprio):
|
||||
u""" Classe définissant l'assoce (pour affichage de ses machines) """
|
||||
def __obj_init__(self, conn=None):
|
||||
_FakeProprio.__obj_init__(self, conn)
|
||||
def __init__(self, conn=None):
|
||||
_FakeProprio.__init__(self, conn)
|
||||
def Nom(self):
|
||||
return u"Crans"
|
||||
def chbre(self):
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue