1
2
3
4
5
6
7
8
9
10
11
12
13 """module de gestion des utilisateurs de l'application
14 """
15 from zephir.backend import config
16 from zephir.backend.config import u, log
17 from zephir.backend.db_utils import *
18 from zephir.backend.entid import IdPoolManager
19 from zephir.backend.lib_backend import serveur_pool
20 from zephir.backend.schedule import TaskScheduler
21 from zephir.backend.dictpool import init_dictpool
22 from zephir.backend.xmlrpceole import XMLRPCEole as XMLRPC
23
24 import sys,base64,ldap,os
25 import traceback
26 import apt_pkg
27
29 """serveur XMLRPC zephir pour la gestion des utilisateurs de l'application
30 """
31
43
45 """renvoie des statistiques générales sur les serveurs"""
46 return 1, u(self.s_pool.get_stats())
47
49 """liste des groupes de droits"""
50
51 query = """select * from groupes_droits"""
52 return self.dbpool.runQuery(query).addCallbacks(self._load_rights,db_client_failed)
53
55 """formattage des groupes de droits
56 """
57
58 droits=[]
59 for groupe in data:
60
61 droits.append([groupe[0],groupe[1],eval(groupe[2])])
62 return 1, u(droits)
63
65 """liste des permissions de l'application pour un utilisateur précis"""
66
67 query = """select login, droits from users where login = %s"""
68 return self.dbpool.runQuery(query, (username,)).addCallbacks(self._get_permissions,db_client_failed)
69
71 try:
72
73 username = data[0][0]
74 groupes = eval(data[0][1])
75 except:
76
77 return 1, []
78
79 return 1, u(groupes)
80
82 """sauvegarde les autorisations de l'utilisateur"""
83
84
85 query = """select login,nom,prenom,mail from users where login = %s"""
86 return self.dbpool.runQuery(query, (username,)).addCallbacks(self._save_permissions,db_client_failed,callbackArgs=[username,user_auths])
87
89
90 if data!=[]:
91 nom=data[0][1]
92 prenom=data[0][2]
93 mail=data[0][3]
94 else:
95 nom=""
96 prenom=""
97 mail=""
98 try:
99 l=ldap.open(config.ADRESSE_LDAP)
100 if config.LDAP_TLS == "oui":
101 l.start_tls_s()
102
103 result=l.search_s(config.BASE_LDAP, ldap.SCOPE_SUBTREE, "(uid="+username+")")
104 res_ldap = result[0][1]
105 l.unbind()
106 if nom == "":
107 try:
108 nom=res_ldap['sn'][0]
109 except KeyError:
110 pass
111 if prenom == "":
112 try:
113 prenom=res_ldap['givenName'][0]
114 except KeyError:
115 pass
116 if mail == "":
117 try:
118 mail=res_ldap['mail'][0]
119 except KeyError:
120 pass
121 except:
122 pass
123 if data != []:
124
125 query = """update users set droits=%s,nom=%s,prenom=%s,mail=%s where login=%s"""
126 params = (str(user_auths), nom, prenom, mail, username)
127 else:
128
129 query = """insert into users (login,mail_actif,sms_actif,droits,nom,prenom,mail) \
130 values (%s,%s,%s,%s,%s,%s,%s)"""
131 params = (username, 0, 0, str(user_auths), nom, prenom, mail)
132
133 return self.dbpool.runOperation(query, params).addCallbacks(lambda x : [1,'ok'],db_client_failed)
134
136 """ajoute des restrictions sur les serveurs accessibles à un utilisateur
137 """
138 try:
139 res = self.s_pool.get_restrictions(login, type_res)
140 except KeyError:
141 return 0, u("utilisateur ou type de contrainte non valides")
142 return 1, u(res)
143
145 """ajoute des restrictions sur les serveurs accessibles à un utilisateur
146 """
147
148 query = """select login,nom,prenom,mail from users where login = %s"""
149 return self.dbpool.runQuery(query, (login,)).addCallbacks(self._add_restriction,db_client_failed,callbackArgs=[login, type_res, id_res])
150
152
153 if data!=[]:
154 nom=data[0][1]
155 prenom=data[0][2]
156 mail=data[0][3]
157 else:
158 nom=""
159 prenom=""
160 mail=""
161 try:
162 l=ldap.open(config.ADRESSE_LDAP)
163 if config.LDAP_TLS == "oui":
164 l.start_tls_s()
165
166 result=l.search_s(config.BASE_LDAP, ldap.SCOPE_SUBTREE, "(uid="+login+")")
167 res_ldap = result[0][1]
168 l.unbind()
169 if nom == "":
170 try:
171 nom=res_ldap['sn'][0]
172 except KeyError:
173 pass
174 if prenom == "":
175 try:
176 prenom=res_ldap['givenName'][0]
177 except KeyError:
178 pass
179 if mail == "":
180 try:
181 mail=res_ldap['mail'][0]
182 except KeyError:
183 pass
184 except:
185 pass
186 if data == []:
187 user_auths = []
188
189 query = """insert into users (login,mail_actif,sms_actif,droits,nom,prenom,mail) \
190 values (%s,%s,%s,%s,%s,%s,%s)"""
191 params = (login, 0, 0, user_auths, nom, prenom, mail)
192 return self.dbpool.runOperation(query, params).addCallbacks(self._add_restriction2,db_client_failed,callbackArgs=[login, type_res, id_res])
193 else:
194 return self._add_restriction2(None, login, type_res, id_res)
195
197
198 if self.s_pool.add_restriction(login, type_res, id_res):
199 return 1, "ok"
200 else:
201 return 0, u("erreur lors de l'ajout de la contrainte")
202
204 """ajoute des restrictions sur les serveurs accessibles à un utilisateur
205 """
206 if self.s_pool.del_restriction(login, type_res, id_res):
207 return 1, "ok"
208 else:
209 return 0, u("erreur, contrainte non retrouvée")
210
212 """renvoie la liste des serveurs accessibles pour un utilisateur (login)
213 """
214 try:
215 return 1, u(self.s_pool.get_allowed_servers(login))
216 except Exception, e:
217 return 0, u("Erreur lors de la recherche des serveurs accessibles pour %s" % login)
218
220 """met à jour la liste des groupes surveillés par l'utilisateur"""
221 query = """update users set groupes = %s where login = %s"""
222 params = (str(groupes),username)
223 return self.dbpool.runOperation(query, params).addCallbacks(lambda x : [1,'ok'],db_client_failed)
224
226 """renvoie les informations d'un utilisateur
227 """
228 query = """select login,mail,nom,prenom,sms,mail_actif,sms_actif,droits,groupes,cle from users where login = %s"""
229 return self.dbpool.runQuery(query, (username,)).addCallbacks(self._get_user,db_client_failed)
230
232 """retourne la liste des utilisateurs"""
233 query = """select login from users order by login asc"""
234 return self.dbpool.runQuery(query).addCallbacks(self._list_users,db_client_failed)
235
237 """formate la sortie de la base de données"""
238 logins=[]
239 for user in data:
240 logins.append(user[0])
241 return 1,u(logins)
242
244 """suppression d'un utilisateur"""
245 if login:
246
247 query = """select libelle from variantes where owner=%s"""
248 return self.dbpool.runQuery(query, (login,)).addCallbacks(self._del_user,db_client_failed,callbackArgs=[cred_user, login])
249 else:
250 return 0,u("""donnez un identifiant""")
251
252 - def _del_user(self, data, cred_user, login):
253 """suppression de l'utilisateur dans la base de données
254 """
255 query = """delete from restrictions where login=%s"""
256 self.dbpool.runOperation(query, (login,))
257 query = """delete from serveur_auth where login=%s"""
258 self.dbpool.runOperation(query, (login,))
259 query = """delete from users where login=%s"""
260 return self.dbpool.runOperation(query, (login,)).addCallbacks(self._update_variantes, db_client_failed, callbackArgs=[data, cred_user, login])
261
263 """réassignation des variantes si besoin
264 """
265 if len(var_data) > 0:
266
267 log.msg("""Utilisateur %s supprimé, réattribution des variantes suivantes à %s : %s""" % (login, cred_user, ", ".join([lib[0] for lib in var_data])))
268 query = """update variantes set owner=%s where owner=%s"""
269 return self.dbpool.runOperation(query, (cred_user, login)).addCallbacks(lambda x : [1,'OK'], db_client_failed)
270 return 1, "OK"
271
272 - def xmlrpc_edit_user(self,cred_user,username,nom,prenom,mail,sms,mail_actif,sms_actif):
273 """édite les informations d'un utilisateur
274 """
275 query = """select * from users where login=%s"""
276 return self.dbpool.runQuery(query, (username,)).addCallbacks(self._edit_user,db_client_failed,callbackArgs=[username,nom,prenom,mail,sms,mail_actif,sms_actif])
277
278 - def _edit_user(self,data,username,nom,prenom,mail,sms,mail_actif,sms_actif):
279 """
280 """
281 if data == []:
282
283 query = """insert into users (login, nom, prenom, mail, sms, mail_actif, sms_actif, droits, \
284 groupes, cle) values (%s,%s,%s,%s,%s,%s,%s,'','','')"""
285 params = (username, nom, prenom, mail, sms, int(mail_actif), int(sms_actif))
286 else:
287 query = """update users set nom=%s, prenom=%s, mail=%s, sms=%s, mail_actif=%s, sms_actif=%s where login=%s"""
288 params = (nom, prenom, mail, sms, int(mail_actif), int(sms_actif), username)
289
290 return self.dbpool.runOperation(query, params).addCallbacks(lambda x : [1,'ok'],db_client_failed)
291
293 """formate la sortie de la base de données"""
294 user=[]
295 if data != []:
296 for field in data[0]:
297 if field in [None, 'None']:
298 user.append("")
299 else:
300 user.append(field)
301
302 if user[7] == "":
303 user[7] = "[]"
304 if user[8] == "":
305 user[8] = "[]"
306 if user[9] != "":
307 user[9] = 1
308 else:
309 user[9] = 0
310
311 return 1, u([user[0],user[1],user[2],user[3],user[4],int(user[5]),int(user[6]),eval(user[7]),eval(user[8]),user[9]])
312 else:
313 return 1, []
314
316 """sauvegarde la cle ssh de l'utilisateur"""
317 query = """update users set cle=%s where login=%s"""
318 params = (cle, cred_user)
319 return self.dbpool.runOperation(query, params).addCallbacks(lambda x : [1,'ok'], db_client_failed)
320
322 """fonction de mise à jour du client disponible sur zephir"""
323
324 try:
325 rpm_dir = os.path.abspath(config.PATH_ZEPHIR)+"/sites/client/"
326 if not os.path.isdir(rpm_dir):
327 os.makedirs(rpm_dir)
328 b_name = os.path.basename(name)
329 rpms = os.listdir(rpm_dir)
330 for rpm in rpms:
331
332 if rpm.startswith(b_name[:b_name.rindex('-')]) and rpm.endswith(os.path.splitext(b_name)[1]):
333 os.unlink(rpm_dir+rpm)
334
335
336 if content == "":
337 import urllib
338 arch_url = ''
339 version = b_name.replace('zephir-client', '')[1:4]
340 if version not in ('2.0', '2.1'):
341 arch_url = 'all/'
342 f_name, message = urllib.urlretrieve('http://' + config.CLIENT_UPDATE_HOST + \
343 config.CLIENT_NG_URL % (version, arch_url) + b_name, rpm_dir + b_name)
344 else:
345 content = base64.decodestring(content)
346 fic_rpm=file(rpm_dir + b_name,'w')
347 fic_rpm.write(content)
348 fic_rpm.close()
349 return 1, "OK"
350 except Exception, e:
351 traceback.print_exc()
352 return 0, u("Erreur de mise a jour du client")
353
355 """suppression d'un client disponible sur zephir"""
356 try:
357 rpm_dir = os.path.abspath(config.PATH_ZEPHIR)+"/sites/client/"
358 rpm = os.path.join(rpm_dir,name)
359 if not os.path.isfile(rpm):
360 return 0, u("Fichier non trouvé %s" % name)
361 os.unlink(rpm)
362 return 1, "OK"
363 except Exception, e:
364 return 0, u("Erreur de suppression du fichier")
365
367 """fonction de vérification de la version du client"""
368
369
370 version = version.split('\n')[0]
371
372 vers_majmin=version[:version.rindex('-')]
373 try:
374 version_locale = ""
375 if os.path.isdir(os.path.abspath(config.PATH_ZEPHIR)+"/sites/client"):
376 rpms=os.listdir(os.path.abspath(config.PATH_ZEPHIR)+"/sites/client")
377 for rpm in rpms:
378
379 if rpm.startswith(vers_majmin):
380 version_locale=rpm
381 break
382 if version_locale == "":
383
384 return 1,"OK"
385 except Exception,e:
386 return 0,u('erreur lors de la lecture de la version sur zephir : %s' % str(e))
387
388 vers_loc = version_locale.replace(vers_majmin,"")
389 vers_dist = version.replace(vers_majmin,"")
390 if version.split('zephir-client')[1][1:].startswith('2'):
391
392 vers_loc = vers_loc[1:vers_loc.index('_')].replace('eole','')
393 vers_dist = vers_dist[1:].replace('eole','')
394 else:
395 vers_loc = vers_loc[1:vers_loc.index('eol')]
396 vers_dist = vers_dist[1:vers_dist.index('eol')]
397
398 maj=0
399 apt_pkg.InitSystem()
400 if apt_pkg.VersionCompare(vers_loc, vers_dist) > 0:
401 maj=1
402 if maj == 1:
403 return 1,u(version_locale.strip())
404 else:
405 return 1,"OK"
406
408 """liste les clients disponibles sur zephir"""
409 try:
410 rpms = []
411 rpm_dir = os.path.abspath(config.PATH_ZEPHIR)+"/sites/client/"
412 if os.path.isdir(rpm_dir):
413 for rpm in os.listdir(rpm_dir):
414 if rpm.startswith('zephir-client'):
415 rpms.append(rpm)
416 return 1, u(rpms)
417 except Exception, e:
418 return 0, u("Erreur de lecture du répertoire")
419