API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jun 9th, 2017
70
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 48.80 KB | None | 0 0
raw download clone embed print report
  1. #!/usr/bin/python
  2.  
  3. import psycopg2
  4. import psycopg2.extras
  5. import base64
  6. import sys
  7. import shlex
  8. import subprocess
  9. import logging
  10. from optparse import OptionParser
  11.  
  12. import ldap
  13. from ldap.controls import SimplePagedResultsControl
  14. import ldap.sasl
  15. import ldap.cidict
  16. from grp import getgrnam
  17. import pwd
  18. import getopt,os
  19. import time
  20. import DbInc
  21.  
  22.  
  23. fields = {
  24. 'WIN2003':{
  25. 'person':['person'],
  26. 'group':['group'],
  27. 'objectguid':['objectGUID','dn','rdn'],
  28. 'displayname':['name','cn','givenName','sn'],
  29. 'description':['description'],
  30. 'memberof':['memberOf'],
  31. 'member':['member'],
  32. 'oname':['sAMAccountName','mailnickname','uid','cn','loginname'],
  33. 'mails':['mail','userPrincipalName','proxyAddresses','rfc822mailbox']
  34. },
  35. 'COMMUNIGATE':{
  36. 'person':['inetOrgPerson'],
  37. 'group':['group'],
  38. 'objectguid':['uid','dn','rdn'],
  39. 'displayname':['name','cn','givenName','sn'],
  40. 'memberof':['memberof'],
  41. 'member':['member'],
  42. 'oname':['sAMAccountName','mailnickname','uid','cn','loginname'],
  43. 'mails':['mail','userPrincipalName','proxyAddresses','rfc822mailbox','email']
  44. },
  45. 'LOTUSNOTES':{
  46. 'person':['inetorgperson'],
  47. 'group':['group'],
  48. 'objectguid':['uid','dn','rdn'],
  49. 'displayname':['name','cn','givenName','sn'],
  50. 'memberof':['memberof'],
  51. 'member':['member'],
  52. 'oname':['sAMAccountName','mailnickname','uid','cn','loginname'],
  53. 'mails':['mail','userPrincipalName','proxyAddresses','rfc822mailbox','email']
  54. },
  55. 'IPLANET':{
  56. 'person':['inetOrgPerson'],
  57. 'group':['groupOfUniqueNames'],
  58. 'objectguid':['uid','dn','rdn'],
  59. 'displayname':['name','cn','givenName','sn'],
  60. 'memberof':['memberof'],
  61. 'member':['uniqueMember'],
  62. 'oname':['sAMAccountName','mailnickname','uid','cn','loginname'],
  63. 'mails':['mail','userPrincipalName','proxyAddresses','rfc822mailbox','email']
  64. },
  65. 'NOVELL':{
  66. 'person':['inetOrgPerson'],
  67. 'group':['groupOfNames'],
  68. 'objectguid':['uid','dn','rdn'],
  69. 'displayname':['name','cn','givenName','sn'],
  70. 'memberof':['groupMembership'],
  71. 'member':['member'],
  72. 'oname':['sAMAccountName','mailnickname','uid','cn','loginname'],
  73. 'mails':['mail','userPrincipalName','proxyAddresses','rfc822mailbox','email']
  74. }
  75. }
  76.  
  77. class paLdap:
  78.  
  79. partly_succesfull_flag = False
  80.  
  81. def __init__(self,_connector,_ldap_fields,loghandler,connect_timeout=5):
  82. self.connector=_connector
  83.  
  84. self.def_domain=''
  85. for part in self.connector['base_dn'].split(","):
  86. if not self.def_domain:
  87. self.def_domain=part.split("=")[1]
  88. else:
  89. self.def_domain += "." + part.split("=")[1]
  90.  
  91. self.log_handler=loghandler
  92. self.ldap_fields=_ldap_fields
  93. self.ldap_timeout = 30
  94. self.connect_timeout = connect_timeout
  95. self.ldap_protocol = 'ldap://'
  96.  
  97. if self.connector['is_ssl'] == 't':
  98. self.ldap_protocol = 'ldaps://'
  99. self.server = ""
  100. #print 'LDAP password:\n\t %s' % base64.b64decode(self.connector['ldap_password'])
  101. #print 'LDAP user:\n\t %s' % self.connector['bind_dn']
  102. self.connect()
  103.  
  104. def connect(self):
  105. for ldap_server in self.connector['server_ip'].split():
  106. self.ldap_url = self.ldap_protocol + ldap_server + ':' + str( self.connector['port'])
  107. self.server = ldap_server
  108. try:
  109. self.conn = ldap.initialize(self.ldap_url)
  110. self.conn.network_timeout = self.connect_timeout
  111. self.conn.set_option(ldap.OPT_REFERRALS, 0)
  112. self.conn.simple_bind_s( self.connector['bind_dn'], base64.b64decode(self.connector['ldap_password']))
  113. return
  114. except ldap.SERVER_DOWN:
  115. LOGGER("LDAP server %s did not respond in %s seconds" % (ldap_server,self.connect_timeout),self.log_handler)
  116. self.conn.unbind_s()
  117. self.conn = None
  118. continue
  119. except ldap.INVALID_CREDENTIALS, e:
  120. print 'Invalid credentials error:\nERROR: %s' % str(e)
  121. LOGGER(str(e),self.log_handler)
  122. sys.exit(1)
  123. except ldap.LDAPError, e:
  124. LOGGER('LDAP connection error:\n\tERROR: %s' % e[0]["desc"],self.log_handler)
  125. sys.exit(1)
  126. LOGGER('No response from LDAP servers',self.log_handler)
  127. sys.exit(1)
  128.  
  129.  
  130. def disconnect(self):
  131. if not self.conn:
  132. return
  133.  
  134. try:
  135. self.conn.unbind_s()
  136. self.conn = None
  137. except ldap.LDAPError, e:
  138. print 'LDAP disconnection error: %s' % str(e)
  139. LOGGER(str(e),self.log_handler)
  140.  
  141. def ldap_paged_search(self, group=0, sizelimit = 0):
  142. ix = 0
  143. base_dn = self.connector['base_dn']
  144. if self.connector["server_type"] == "OPENLDAP":
  145. self.fields = {
  146. 'person':[self.connector["ldap_person_class"]],
  147. 'group':[self.connector["ldap_group_class"]],
  148. 'objectguid':[self.connector["ldap_group_id"]],
  149. 'displayname':[self.connector["ldap_display_name"],'name','cn','givenName','sn'],
  150. 'dn':[self.connector["ldap_dn"]],
  151. 'memberof':[self.connector["ldap_member_of"]],
  152. 'member':[self.connector["ldap_member"]],
  153. 'oname':[self.connector["ldap_cn"]],
  154. 'mails':[self.connector["ldap_email"]],
  155. 'description':['description']
  156. }
  157. else:
  158. self.fields = self.ldap_fields.get(self.connector["server_type"])
  159.  
  160. if self.connector["ldap_filter"] == '':
  161. objectClassUsers = self.fields["person"][0]
  162. else:
  163. objectClassUsers = self.connector["ldap_filter"]
  164.  
  165. if self.connector["ldap_group_filter"] == '':
  166. objectClassGroups = self.fields["group"][0]
  167. else:
  168. objectClassGroups = self.connector["ldap_group_filter"]
  169.  
  170. self.attrs = []
  171. for field in self.fields.items():
  172. self.attrs.extend(field[1][0].split(","))
  173.  
  174. if not group:
  175. query = "(%s)" % objectClassUsers
  176. else:
  177. query = "(%s)" % objectClassGroups
  178.  
  179. self.ldap_page_size = 0
  180.  
  181. try:
  182. msgid_test = self.conn.search_ext(base_dn, ldap.SCOPE_SUBTREE, query, attrlist=self.attrs, serverctrls=[])
  183. res_test = self.conn.result3(msgid=msgid_test, timeout=self.ldap_timeout)
  184. except ldap.SIZELIMIT_EXCEEDED, e:
  185. self.disconnect()
  186. self.connect()
  187. self.ldap_page_size = 100
  188. self.paged_results_control = SimplePagedResultsControl(True, self.ldap_page_size, '')
  189. except ldap.FILTER_ERROR, e:
  190. LOGGER('LDAP filter error:\n\tERROR: %s' % e[0]["desc"], self.log_handler)
  191. sys.exit()
  192.  
  193. while True:
  194. if self.ldap_page_size == 0:
  195. serverctrls = []
  196. else:
  197. serverctrls = [self.paged_results_control]
  198.  
  199. try:
  200. msgid = self.conn.search_ext(base_dn, ldap.SCOPE_SUBTREE, query, attrlist=self.attrs, serverctrls=serverctrls)
  201. res = self.conn.result3(msgid=msgid, timeout=self.ldap_timeout)
  202. unused_code, results, unused_msgid, serverctrls = res
  203. except ldap.FILTER_ERROR, e:
  204. LOGGER('LDAP filter error:\n\tERROR: %s' % e[0]["desc"], self.log_handler)
  205. sys.exit()
  206.  
  207. for result in results:
  208. ix += 1
  209. #users.append(result)
  210. yield result
  211. if sizelimit and ix >= sizelimit:
  212. self.partly_succesfull_flag = True
  213. break
  214. if sizelimit and ix >= sizelimit:
  215. self.partly_succesfull_flag = True
  216. break
  217. cookie = None
  218. for serverctrl in serverctrls:
  219. if serverctrl.controlType == ldap.CONTROL_PAGEDRESULTS:
  220. cookie = serverctrl.cookie
  221. if cookie:
  222. self.paged_results_control.cookie = cookie
  223. break
  224. if not cookie:
  225. break
  226.  
  227. def get_connector_users(self):
  228. self.users = {}
  229. #LOGGER("got obj from ldap",self.log_handler)
  230. #print self.def_domain
  231. counter = 0
  232. for user in self.ldap_paged_search():
  233. self.ldap_ogid = ''
  234. tmp_user={}
  235. if type(user[1]) is dict:
  236. #print user
  237.  
  238. tmp_user["isgroup"] = 0
  239. tmp_user["obj_dn"] = user[0]
  240.  
  241. for attributes in self.fields["objectguid"]:
  242. for attr in attributes.split(","):
  243. if user[1].has_key(attr):
  244. self.ldap_ogid = user[1][attr][0].encode('hex')
  245. break
  246.  
  247. if not self.ldap_ogid:
  248. self.ldap_ogid = user[0].encode('hex')
  249.  
  250. for attributes in self.fields["displayname"]:
  251. for attr in attributes.split(","):
  252. if user[1].has_key(attr):
  253. tmp_user["obj_full_name"] = user[1][attr][0]
  254. break
  255.  
  256. not_valid_user = False
  257. for attributes in self.fields["oname"]:
  258. for attr in attributes.split(","):
  259. if user[1].has_key(attr):
  260. if "$" not in user[1][attr][0].lower():
  261. #tmp_user["userlogin"] = user[1][attr][0].replace(' ','_')
  262. tmp_user["obj_login"] = user[1][attr][0].lower()
  263. break
  264. else:
  265. not_valid_user = True
  266. if not tmp_user.has_key("obj_login"):
  267. not_valid_user = True
  268. if not_valid_user:
  269. continue
  270.  
  271. #tmp_user["oname"] += "@" + self.def_domain
  272. #tmp_user["userlogin"] += "@" + self.def_domain
  273.  
  274. aliases = []
  275. tmp_aliases = set()
  276. for attributes in self.fields["mails"]:
  277. for attr in attributes.split(","):
  278. if user[1].has_key(attr):
  279. for alias in user[1][attr]:
  280. pe=alias.split(":")
  281. if pe[0].lower() == "smtp":
  282. if pe[1].lower() not in aliases:
  283. aliases.append(pe[1].lower())
  284. elif "@" in alias and alias.lower() not in aliases:
  285. aliases.append(alias.lower())
  286.  
  287. if len(aliases):
  288. tmp_user["email"] = aliases[0]
  289. else:
  290. #tmp_user["email"] = "%s@%s" % (tmp_user["userlogin"], self.def_domain)
  291. tmp_user["email"] = "%s@%s" % (tmp_user["obj_login"], self.def_domain)
  292.  
  293. if len(aliases) > 0:
  294. #tmp_user["def_email"] = aliases[0]
  295. tmp_user["email"] = aliases[0]
  296. tmp_aliases = set(aliases[1:])
  297.  
  298. tmp_user["aliases"] = tmp_aliases
  299.  
  300. memberOf = set()
  301. for attributes in self.fields["memberof"]:
  302. for attr in attributes.split(","):
  303. if user[1].has_key(attr):
  304. for group in user[1][attr]:
  305. memberOf.add(group)
  306.  
  307. tmp_user["memberOf"] = memberOf
  308. counter += 1
  309. self.users[str(self.ldap_ogid)]=tmp_user
  310. return counter
  311.  
  312. def get_connector_groups(self):
  313. self.groups = {}
  314. self.ldap_ogid = ''
  315.  
  316. for group in self.ldap_paged_search(1):
  317. tmp_group={}
  318. if type(group[1]) is dict:
  319. #print group
  320. tmp_group["isgroup"] = 1
  321. #tmp_group["group_dn"] = group[0]
  322. tmp_group["obj_dn"] = group[0]
  323.  
  324. for attributes in self.fields["objectguid"]:
  325. for attr in attributes.split(","):
  326. if group[1].has_key(attr):
  327. self.ldap_ogid = group[1][attr][0].encode('hex')
  328. break
  329.  
  330. if not self.ldap_ogid:
  331. self.ldap_ogid = group[0].encode('hex')
  332.  
  333. for attributes in self.fields["displayname"]:
  334. for attr in attributes.split(","):
  335. if group[1].has_key(attr):
  336. #tmp_group["fullname"] = group[1][attr][0]
  337. tmp_group["obj_full_name"] = group[1][attr][0]
  338. break
  339.  
  340. for attributes in self.fields["description"]:
  341. for attr in attributes.split(","):
  342. if group[1].has_key(attr):
  343. tmp_group["obj_description"] = group[1][attr][0]
  344. break
  345. else:
  346. tmp_group["obj_description"] = 'None'
  347.  
  348. members = set()
  349. for attributes in self.fields["member"]:
  350. for attr in attributes.split(","):
  351. if group[1].has_key(attr):
  352. for user in group[1][attr]:
  353. members.add(user)
  354.  
  355. tmp_group["member"] = members
  356.  
  357. for attributes in self.fields["oname"]:
  358. for attr in attributes.split(","):
  359. if group[1].has_key(attr):
  360. #tmp_group["oname"] = group[1][attr][0].replace(' ','_')
  361. #tmp_group["userlogin"] = group[1][attr][0].replace(' ','_')
  362. #tmp_group["userlogin"] = group[1][attr][0]
  363. tmp_group["obj_login"] = group[1][attr][0]
  364. break
  365.  
  366. #tmp_group["oname"] += "@" + self.def_domain
  367. #tmp_group["userlogin"] += "@" + self.def_domain
  368.  
  369. aliases = []
  370. tmp_aliases = set()
  371. for attributes in self.fields["mails"]:
  372. for attr in attributes.split(","):
  373. if group[1].has_key(attr):
  374. for alias in group[1][attr]:
  375. pe=alias.split(":")
  376. if pe[0].lower() == "smtp":
  377. if pe[1].lower() not in aliases:
  378. aliases.append(pe[1].lower())
  379. elif "@" in alias and alias.lower() not in aliases:
  380. aliases.append(alias.lower())
  381.  
  382. if len(aliases) > 0:
  383. tmp_group["def_email"] = aliases[0]
  384. tmp_aliases = set(aliases[1:])
  385.  
  386. tmp_group["aliases"] = tmp_aliases
  387.  
  388. self.groups[str(self.ldap_ogid)]=dict(tmp_group)
  389.  
  390. #if len(tmp_group["aliases"]) or tmp_group.has_key("def_email"):
  391. # tmp_group["isgroup"] = 0
  392. # tmp_group["oname"] += "_aga"
  393. # tmp_group["dn"] += " Auto-group alias"
  394. # tmp_group["fullName"] += " Auto-group alias"
  395. # self.users[str(self.ldap_ogid + "_aga")] = tmp_group
  396.  
  397.  
  398. def __del__(self):
  399. self.disconnect()
  400.  
  401. class paDB:
  402. def __init__(self,loghandler):
  403. self.log_handler=loghandler
  404. try:
  405. _db='um'
  406. _user='postgres'
  407. _host='127.0.0.1'
  408. #_host='192.168.7.202'
  409. #self.db=psycopg2.connect(database='secure',host='192.168.7.102',user='pineapp')
  410. self.db = psycopg2.connect(database=_db,user=_user,host=_host)
  411. self.cur=self.db.cursor(cursor_factory=psycopg2.extras.DictCursor)
  412. except:
  413. # Get the most recent exception
  414. exceptionType, exceptionValue, exceptionTraceback = sys.exc_info()
  415. # Exit the script and print an error telling what happened.
  416. LOGGER("Database connection failed!\n ->%s" % (exceptionValue),self.log_handler)
  417. sys.exit("Database connection failed!\n ->%s" % (exceptionValue))
  418.  
  419. def get_connectors(self):
  420. self.cur.execute(DbInc.Queries["SELECT"]["connectors"])
  421. self.connectors=self.cur.fetchall()
  422.  
  423. def get_connector(self,connectorID):
  424. self.cur.execute(DbInc.Queries["SELECT"]["connector"],[connectorID])
  425. self.connectors=self.cur.fetchall()
  426.  
  427. def buid_membership(self):
  428. self.cur.execute(DbInc.Queries["SELECT"]["user_member_of"])
  429. result = self.cur.fetchall()
  430.  
  431. self.memberShip = {}
  432. for row in result:
  433. if self.memberShip.has_key(row["groupdn"]):
  434. self.memberShip[row["groupdn"]].add(row["userdn"])
  435. else:
  436. memberset = set()
  437. memberset.add(row["userdn"])
  438. self.memberShip[row["groupdn"]] = memberset
  439. self.cur.execute(DbInc.Queries["SELECT"]["group_member_of"])
  440. result = self.cur.fetchall()
  441.  
  442. for row in result:
  443. if self.memberShip.has_key(row["pgdn"]):
  444. self.memberShip[row["pgdn"]].add(row["groupdn"])
  445. else:
  446. memberset = set()
  447. memberset.add(row["groupdn"])
  448. self.memberShip[row["pgdn"]] = memberset
  449.  
  450. def get_aliases(self):
  451. self.user_aliases = {}
  452. self.cur.execute(DbInc.Queries["SELECT"]["users_aliases"])
  453. _user_aliases = self.cur.fetchall()
  454.  
  455. for row in _user_aliases:
  456. if self.aliases.has_key(row["object_id"]):
  457. if row["default_email_ind"] is True:
  458. self.user_aliases[row["object_id"]]['def_email'] = row["email"].lower()
  459. self.user_aliases[row["object_id"]]['emails'].add(row["email"].lower())
  460. else:
  461. self.user_aliases[row["object_id"]]['emails'].add(row["email"].lower())
  462. else:
  463. item = {}
  464. item['def_email'] = ''
  465. item['emails'] = set()
  466. if row["default_email_ind"] is True:
  467. item['def_email'] = row["email"].lower()
  468. item['emails'].add(row["email"].lower())
  469. else:
  470. item['emails'].add(row["email"].lower())
  471.  
  472. self.user_aliases[row["object_id"]] = item
  473.  
  474. self.group_aliases = {}
  475. self.cur.execute(DbInc.Queries["SELECT"]["groups_aliases"])
  476. _group_aliases = self.cur.fetchall()
  477.  
  478. for row in _group_aliases:
  479. if self.aliases.has_key(row["object_id"]):
  480. if row["default_email_ind"] is True:
  481. self.group_aliases[row["object_id"]]['def_email'] = row["email"].lower()
  482. self.group_aliases[row["object_id"]]['emails'].add(row["email"].lower())
  483. else:
  484. self.group_aliases[row["object_id"]]['emails'].add(row["email"].lower())
  485. else:
  486. item = {}
  487. item['def_email'] = ''
  488. item['emails'] = set()
  489. if row["default_email_ind"] is True:
  490. item['def_email'] = row["email"].lower()
  491. item['emails'].add(row["email"].lower())
  492. else:
  493. item['emails'].add(row["email"].lower())
  494.  
  495. self.group_aliases[row["uid"]] = item
  496.  
  497.  
  498. def get_objects(self,_connectorId):
  499. self.objects = {}
  500.  
  501. query = DbInc.Queries["SELECT"]["users_objects"]
  502. data =(str(_connectorId),)
  503. self.cur.execute(query,data)
  504. _users = self.cur.fetchall()
  505. query = DbInc.Queries["SELECT"]["groups_objects"]
  506. data =(str(_connectorId),)
  507. self.cur.execute(query,data)
  508. _groups = self.cur.fetchall()
  509.  
  510. self.InitialSqlObjects = []
  511. self.InitialSqlObjects.extend(_users)
  512. self.InitialSqlObjects.extend(_groups)
  513.  
  514. #_objects=[]
  515. #_objects.extend(_users)
  516. #_objects.extend(_groups)
  517.  
  518. for user in _users:
  519. tmp_obj={}
  520. self.ldap_ogid = user["ldap_ogid"]
  521. tmp_obj["obj_dn"] = user["user_dn"]
  522. tmp_obj["obj_id"] = user["id"]
  523. tmp_obj["obj_login"] = user["userlogin"]
  524. tmp_obj["obj_full_name"] = user["fullname"]
  525. tmp_obj["aliases"] = user["email"]
  526. tmp_obj["email"] = user["email"]
  527. tmp_obj["obj_group_ind"] = 0
  528. #if self.aliases.has_key(object["user_id"]):
  529. # #tmp_obj["default_email_ind"] = self.user_aliases[object["user_id"]]["default_email_ind"]
  530. # tmp_obj["def_email"] = self.user_aliases[user["user_id"]]["def_email"]
  531. # tmp_obj["aliases"] = self.user_aliases[user["user_id"]]["emails"]
  532. self.objects[self.ldap_ogid] = tmp_obj
  533.  
  534. for group in _groups:
  535. tmp_obj={}
  536. self.ldap_ogid = group["ldap_ogid"]
  537. tmp_obj["obj_dn"] = group["group_dn"]
  538. tmp_obj["obj_id"] = group["id"]
  539. tmp_obj["obj_login"] = group["groupname"]
  540. tmp_obj["obj_full_name"] = group["groupname"]
  541. tmp_obj["obj_description"] = group["description"]
  542. #tmp_obj["aliases"] = group["email"]
  543. tmp_obj["aliases"] = ''
  544. tmp_obj["email"] = ''
  545. tmp_obj["obj_group_ind"] = 1
  546. #if self.aliases.has_key(object["user_id"]):
  547. # #tmp_obj["default_email_ind"] = self.group_aliases[object["group_id"]]["default_email_ind"]
  548. # tmp_obj["def_email"] = self.group_aliases[user["group_id"]]["def_email"]
  549. # tmp_obj["aliases"] = self.group_aliases[user["group_id"]]["emails"]
  550.  
  551. self.objects[self.ldap_ogid] = tmp_obj
  552.  
  553. def add_object(self, object, key, connector_id, debug,isgroup):
  554. #print "add_object object = [ %s ]" % object
  555. Log = {}
  556. if not isgroup:
  557. query = DbInc.Queries["INSERT"]["user"]
  558. #data =(object["userlogin"], object["fullname"], object["email"], 1, object["user_dn"], key, connector_id)
  559. data =(object["obj_login"].lower(), object["obj_full_name"], object["email"], 1, object["obj_dn"], key, connector_id)
  560.  
  561. try:
  562. self.cur.execute(query,data)
  563. except psycopg2.IntegrityError as e:
  564. if e.pgcode == "23505":
  565. print "\nbaseDN=%s\n" % object["obj_dn"]
  566. sys.exit(12)
  567. raise e
  568.  
  569. #self.cur.execute("SELECT currval('pineapp.objects_oid_seq')")
  570. #curr_oid = self.cur.fetchone()
  571.  
  572. if Log.has_key("log") or Log.has_key("debug"):
  573. Log["log"] += "Adding NEW user: %s" % (object["obj_full_name"])
  574. Log["debug"] += "\n" + Log["log"]
  575. else:
  576. Log["log"] = "Adding NEW user: %s" % (object["obj_full_name"])
  577. Log["debug"] = "\n" + Log["log"]
  578.  
  579. if debug:
  580. if Log.has_key("log") or Log.has_key("debug"):
  581. Log["debug"] += "\n\t%s" % (self.cur.mogrify(query,data))
  582. else:
  583. Log["debug"] = "\n\t%s" % (self.cur.mogrify(query,data))
  584. else:
  585. query = DbInc.Queries["INSERT"]["group"]
  586. #data =(object["userlogin"], object["group_dn"], key, 1, connector_id)
  587. data =(object["obj_login"], object["obj_dn"], key, 1, connector_id, object["obj_description"])
  588.  
  589. try:
  590. self.cur.execute(query,data)
  591. except psycopg2.IntegrityError as e:
  592. if e.pgcode == "23505":
  593. print "\nbaseDN=%s\n" % object["obj_dn"]
  594. sys.exit(12)
  595. raise e
  596.  
  597. if Log.has_key("log") or Log.has_key("debug"):
  598. Log["log"] += "Adding NEW group: %s" % (object["obj_login"])
  599. Log["debug"] = "\n" + Log["log"]
  600. else:
  601. Log["log"] = "Adding NEW group: %s" % (object["obj_login"])
  602. Log["debug"] = "\n" + Log["log"]
  603.  
  604. if debug:
  605. if Log.has_key("debug"):
  606. Log["debug"] += "\n\t%s" % (self.cur.mogrify(query,data))
  607. else:
  608. Log["debug"] = "\n\t%s" % (self.cur.mogrify(query,data))
  609.  
  610. return Log
  611.  
  612. def update_object(self, ldap_user, ldap_userid , _connectorId, debug,isgroup):
  613. Log = {}
  614. userUpToDate = 1
  615.  
  616. if debug:
  617. if Log.has_key("debug"):
  618. if not isgroup:
  619. Log["debug"] += "Processing: %s\n" % (ldap_user["obj_full_name"])
  620. if isgroup:
  621. Log["debug"] += "Processing: %s\n" % (ldap_user["obj_login"])
  622. else:
  623. if not isgroup:
  624. Log["debug"] = "Processing: %s\n" % (ldap_user["obj_full_name"])
  625. if isgroup:
  626. Log["debug"] = "Processing: %s\n" % (ldap_user["obj_login"])
  627.  
  628. for key,val in ldap_user.items():
  629. if self.objects[ldap_userid].has_key(key):
  630. if not type(self.objects[ldap_userid][key]).__name__ == 'set':
  631. if not ldap_user[key] == self.objects[ldap_userid][key]:
  632.  
  633. if key == "obj_login":
  634. if not ldap_user[key].lower() == self.objects[ldap_userid][key].lower():
  635. if not isgroup:
  636. query = DbInc.Queries["UPDATE"]["user_login"]
  637. data =(ldap_user[key].lower(), self.objects[ldap_userid]["obj_id"],)
  638.  
  639. if Log.has_key("log"):
  640. Log["log"] += "\nUpdating User Login \"%s\" to \"%s\"" % (self.objects[ldap_userid][key], ldap_user[key].lower())
  641. else:
  642. Log["log"] = "Updating User Login \"%s\" to \"%s\"" % (self.objects[ldap_userid][key], ldap_user[key].lower())
  643. if debug:
  644. if Log.has_key("debug"):
  645. Log["debug"] += "\t%s\n" % (self.cur.mogrify(query,data))
  646. else:
  647. Log["debug"] = "\t%s\n" % (self.cur.mogrify(query,data))
  648.  
  649. if isgroup:
  650. query = DbInc.Queries["UPDATE"]["group_login"]
  651. data =(ldap_user[key], self.objects[ldap_userid]["obj_id"],)
  652.  
  653. if Log.has_key("log"):
  654. Log["log"] += "\nUpdating Group Login \"%s\" to \"%s\"" % (self.objects[ldap_userid][key], ldap_user[key])
  655. else:
  656. Log["log"] = "Updating Group Login \"%s\" to \"%s\"" % (self.objects[ldap_userid][key], ldap_user[key])
  657. if debug:
  658. if Log.has_key("debug"):
  659. Log["debug"] += "\t%s\n" % (self.cur.mogrify(query,data))
  660. else:
  661. Log["debug"] = "\t%s\n" % (self.cur.mogrify(query,data))
  662.  
  663. self.cur.execute(query, data)
  664. userUpToDate = 0
  665.  
  666.  
  667. if key == "obj_full_name":
  668. if not isgroup:
  669. query = DbInc.Queries["UPDATE"]["user_fullname"]
  670. data =(ldap_user[key], self.objects[ldap_userid]["obj_id"],)
  671. self.cur.execute(query,data)
  672.  
  673. userUpToDate = 0
  674. if Log.has_key("log"):
  675. Log["log"] += "\nOID(%s) Updating User fullname \"%s\" to \"%s\"" % (self.objects[ldap_userid]["obj_id"],self.objects[ldap_userid][key], ldap_user[key])
  676. else:
  677. Log["log"] = "OID(%s) Updating User fullname \"%s\" to \"%s\"" % (self.objects[ldap_userid]["obj_id"],self.objects[ldap_userid][key], ldap_user[key])
  678. if debug:
  679. if Log.has_key("debug"):
  680. Log["debug"] += "\t%s\n" % (self.cur.mogrify(query,data))
  681. else:
  682. Log["debug"] = "\t%s\n" % (self.cur.mogrify(query,data))
  683.  
  684. if key == "obj_dn":
  685. if isgroup:
  686. query = DbInc.Queries["UPDATE"]["group_dn"]
  687. else:
  688. query = DbInc.Queries["UPDATE"]["user_dn"]
  689.  
  690. data =(ldap_user[key],self.objects[ldap_userid]["obj_id"],)
  691. self.cur.execute(query,data)
  692.  
  693. if Log.has_key("log"):
  694. Log["log"] += "\nUpdating dn \"%s\" to \"%s\"" % (self.objects[ldap_userid][key], ldap_user[key])
  695. else:
  696. Log["log"] = "Updating dn \"%s\" to \"%s\"" % (self.objects[ldap_userid][key], ldap_user[key])
  697.  
  698. if debug:
  699. userUpToDate = 0
  700. if Log.has_key("debug"):
  701. Log["debug"] += "\t%s\n" % (self.cur.mogrify(query,data))
  702. else:
  703. Log["debug"] = "\t%s\n" % (self.cur.mogrify(query,data))
  704.  
  705. if key == "obj_description":
  706. if isgroup:
  707. query = DbInc.Queries["UPDATE"]["group_description"]
  708. data =(ldap_user[key], self.objects[ldap_userid]["obj_id"],)
  709. self.cur.execute(query, data)
  710.  
  711. if Log.has_key("log"):
  712. Log["log"] += "\nUpdating Group Description \"%s\" to \"%s\"" % (self.objects[ldap_userid][key], ldap_user[key])
  713. else:
  714. Log["log"] = "Updating Group Description \"%s\" to \"%s\"" % (self.objects[ldap_userid][key], ldap_user[key])
  715.  
  716. if debug:
  717. userUpToDate = 0
  718. if Log.has_key("debug"):
  719. Log["debug"] += "\t%s\n" % (self.cur.mogrify(query,data))
  720. else:
  721. Log["debug"] = "\t%s\n" % (self.cur.mogrify(query,data))
  722.  
  723. if debug:
  724. if userUpToDate:
  725. if Log.has_key("debug"):
  726. Log["debug"] += "\t%s is Up to date" % (ldap_user["obj_full_name"])
  727. else:
  728. Log["debug"] = "\t%s is Up to date" % (ldap_user["obj_full_name"])
  729.  
  730. return Log
  731.  
  732. def del_object(self, object, debug):
  733. Log = {}
  734. if object["obj_group_ind"]:
  735. query = DbInc.Queries["DELETE"]["group"]
  736. else:
  737. query = DbInc.Queries["DELETE"]["user"]
  738.  
  739. data =(object["obj_id"],)
  740. if not object["obj_group_ind"]:
  741. if Log.has_key("log"):
  742. Log["log"] += "\nRemoving user: %s" % (object["obj_full_name"])
  743. else:
  744. Log["log"] = "Removing user: %s" % (object["obj_full_name"])
  745. else:
  746. if Log.has_key("log"):
  747. Log["log"] += "\nRemoving Group: %s" % (object["obj_full_name"])
  748. else:
  749. Log["log"] = "Removing Group: %s" % (object["obj_full_name"])
  750.  
  751. if debug:
  752. if Log.has_key("debug"):
  753. Log["debug"] += "\n\t%s" % (self.cur.mogrify(query,data))
  754. else:
  755. Log["debug"] = "\t%s" % (self.cur.mogrify(query,data))
  756.  
  757. self.cur.execute(query,data)
  758. return Log
  759.  
  760. def build_DN2OID(self,_connectorId):
  761. self.user_DN2OID = {}
  762. self.group_DN2OID = {}
  763.  
  764. query = DbInc.Queries["SELECT"]["users_objects"]
  765. data =(str(_connectorId),)
  766. self.cur.execute(query,data)
  767. res = self.cur.fetchall()
  768. for row in res:
  769. self.user_DN2OID[row["user_dn"]]=row["id"]
  770.  
  771. query = DbInc.Queries["SELECT"]["groups_objects"]
  772. data =(str(_connectorId),)
  773. self.cur.execute(query,data)
  774. res = self.cur.fetchall()
  775. for row in res:
  776. self.group_DN2OID[row["group_dn"]]=row["id"]
  777.  
  778. def add_object2group(self, objectID, groupID, isgroup, debug):
  779. Log = {}
  780. if isgroup:
  781. query = DbInc.Queries["INSERT"]["group_member_of"]
  782. else:
  783. query = DbInc.Queries["INSERT"]["user_member_of"]
  784.  
  785. data =(objectID, groupID)
  786. self.cur.execute(query,data)
  787. if debug:
  788. if Log.has_key("debug"):
  789. Log["debug"] += "\t%s\n" % (self.cur.mogrify(query,data))
  790. else:
  791. Log["debug"] = "\t%s\n" % (self.cur.mogrify(query,data))
  792.  
  793. def del_object2group(self, objectID, groupID, isgroup, debug):
  794. Log = {}
  795. if isgroup:
  796. query = DbInc.Queries["DELETE"]["group_member_of"]
  797. else:
  798. query = DbInc.Queries["DELETE"]["user_member_of"]
  799. data =(objectID, groupID)
  800. self.cur.execute(query,data)
  801.  
  802. if debug:
  803. if Log.has_key("debug"):
  804. Log["debug"] += "\t%s\n" % (self.cur.mogrify(query,data))
  805. else:
  806. Log["debug"] = "\t%s\n" % (self.cur.mogrify(query,data))
  807.  
  808. def set_ldapogid(self, dn, ldapogid, isgroup, debug):
  809. Log = {}
  810. if isgroup:
  811. query = DbInc.Queries["UPDATE"]["group_ldap_ogid"]
  812. else:
  813. query = DbInc.Queries["UPDATE"]["user_ldap_ogid"]
  814.  
  815. data =(dn, ldapogid)
  816. self.cur.execute(query,data)
  817.  
  818. if Log.has_key("log"):
  819. Log["log"] += "\nSetting Up LdapOgid (%s) for: (%s)" % (dn, ldapogid)
  820. else:
  821. Log["log"] = "Setting Up LdapOgid (%s) for: (%s)" % (dn, ldapogid)
  822.  
  823. if debug:
  824. if Log.has_key("debug"):
  825. Log["debug"] += "\t%s\n" % (self.cur.mogrify(query,data))
  826. else:
  827. Log["debug"] = "\t%s\n" % (self.cur.mogrify(query,data))
  828.  
  829. return Log
  830.  
  831. def ldap_ogid_exists(self):
  832. """Get information about ldap_ogid column"""
  833. self.cur.execute("""
  834. SELECT 1
  835. FROM information_schema.columns
  836. WHERE column_name = 'ldap_ogid'
  837. """)
  838. return True if self.cur.rowcount else False
  839.  
  840. def add_ldap_ogid_column(self):
  841. """Alter db schema and add missing column"""
  842. sql = [
  843. 'alter table policy.users add column ldap_ogid character varying;',
  844. 'alter table policy.groups add column ldap_ogid character varying;'
  845. ]
  846. try:
  847. for query in sql:
  848. self.cur.execute(query)
  849. self.db.commit()
  850. return True
  851. except Exception as e:
  852. print e
  853. self.db.rollback()
  854.  
  855.  
  856. def LOGGER(msg):
  857. logger = logging.getLogger('ldap_sync')
  858. hdlr = logging.FileHandler('./ldap_sync.log')
  859. #formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
  860. formatter = logging.Formatter('%(asctime)s %(name)s %(message)s')
  861. hdlr.setFormatter(formatter)
  862. logger.addHandler(hdlr)
  863. logger.setLevel(logging.INFO)
  864. logger.info(msg)
  865.  
  866. def LOGGER(msg,hndl):
  867. hndl.info(msg)
  868. print msg
  869.  
  870. def init_LOGGER():
  871. logger = logging.getLogger('ldap_sync')
  872. hdlr = logging.FileHandler('/tmp/ldap_sync.log')
  873. os.fchown(hdlr.stream.fileno(),pwd.getpwnam('apache').pw_uid,getgrnam("apache").gr_gid)
  874. #formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
  875. formatter = logging.Formatter('%(asctime)s %(name)s %(message)s')
  876. hdlr.setFormatter(formatter)
  877. logger.addHandler(hdlr)
  878. logger.setLevel(logging.INFO)
  879. return logger
  880.  
  881. def runsystemcmd(cmd, debug, log_handler):
  882. LOGGER("Running: %s" % cmd ,log_handler)
  883. #(output, err) = subprocess.Popen(shlex.split(cmd), stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True).communicate()
  884. p = subprocess.Popen(shlex.split(cmd), shell = False)
  885. try:
  886. os.waitpid(p.pid, 0)[1]
  887. except:
  888. pass
  889.  
  890. def main():
  891. parser = OptionParser()
  892. parser.add_option("-d", "--debug", dest="debug", action="store_true", default=False, help="set DEBUG true")
  893. parser.add_option("-l", "--ldapid", dest="ldapid", action="store", help="Test LDAP connector ID")
  894. parser.add_option("--connectorid", dest="connectorid", action="store", help="Synchronize connector ID")
  895. parser.add_option ("--SetLdapOgid", dest="SetLdapOgid", action="store_true", default=False, help="Setting LdapOgids of existing users and groups in case that are missing ...")
  896. (options, args) = parser.parse_args(sys.argv[1:])
  897.  
  898. log_handler=init_LOGGER()
  899. #print options
  900. debug = options.debug
  901. connectorID = None
  902. check_only = False
  903. partly_successful_flag = False
  904. user_counter = 0
  905.  
  906. # Check if python-ldap up to date, or ldap paged search will fail
  907. ldap_version = tuple(int(i) for i in ldap.__version__.split("."))
  908. if ldap_version < (2, 4):
  909. LOGGER("python-ldap module version is lover than 2.4,"
  910. "update needed.", log_handler)
  911. sys.exit(1)
  912.  
  913. try:
  914. with open("/usr/local/pineapp/x700/etc/PA_ALLOWED_USERS", "r") as allowed_users_file:
  915. max_allowed_users = allowed_users_file.read()
  916. try:
  917. max_allowed_users = int(max_allowed_users)
  918. except:
  919. LOGGER("illegal file contents (expected int)", log_handler)
  920. # if we can't read max users consider we have unlimited license
  921. max_allowed_users = 0
  922. except IOError:
  923. LOGGER("Allowed users file does not exists", log_handler)
  924. # if we can't read max users consider we have unlimited license
  925. max_allowed_users = 0
  926.  
  927. if options.ldapid:
  928. try:
  929. connectorID = int(options.ldapid)
  930. check_only = True
  931. except:
  932. print("Connector ID should be integer!")
  933. sys.exit(1)
  934. elif options.connectorid:
  935. try:
  936. connectorID = int(options.connectorid)
  937. except:
  938. print("Connector ID should be integer!")
  939. sys.exit(1)
  940.  
  941. if options.ldapid and options.connectorid:
  942. print("Test and synchronize commands cannot be used together. Please choose one only.")
  943. sys.exit(1)
  944. if debug:
  945. debugLog = ''
  946. LOGGER("START",log_handler)
  947.  
  948. sql=paDB(log_handler)
  949. if connectorID:
  950. sql.get_connector(connectorID)
  951. else:
  952. sql.get_connectors()
  953.  
  954. if len(sql.connectors) == 0:
  955. print("Connector with ID %s wasn't found." % connectorID)
  956. sys.exit(1)
  957.  
  958. #for connector in sql.connectors:
  959. # print connector
  960. # print "\n\n"
  961. #sys.exit()
  962. #LOGGER("fin connectors",log_handler)
  963.  
  964. # some backuped schema may not contain column `ldap_ogid`, try to add it
  965. if not sql.ldap_ogid_exists():
  966. LOGGER(
  967. "Missing `ldap_ogid` in policy schema, adding...", log_handler)
  968. if not sql.add_ldap_ogid_column():
  969. sys.exit(1)
  970.  
  971. cix = 0
  972. for connector in sql.connectors:
  973. pldap=paLdap(connector,fields,log_handler)
  974. if check_only:
  975. #pldap.connect()
  976. pldap.disconnect()
  977. sys.exit(0)
  978. ldap_memberShip = {}
  979. LOGGER("Synchronizing against LDAP (%s)" % (pldap.server),log_handler)
  980.  
  981. user_count = pldap.get_connector_users()
  982. pldap.get_connector_groups()
  983.  
  984. ldap_objects = {}
  985. if max_allowed_users == 0:
  986. ldap_objects.update(pldap.users)
  987. elif user_counter + user_count <= max_allowed_users:
  988. # in case when connector user count is lower than
  989. # max_users
  990. ldap_objects.update(pldap.users)
  991. user_counter += user_count
  992. elif user_counter < max_allowed_users < user_counter + user_count:
  993. # in case when max_users limit is not yet used and
  994. # connector has another chunk of objects
  995. for key, user in pldap.users.items():
  996. if user_counter == max_allowed_users:
  997. partly_successful_flag = True
  998. break
  999. ldap_objects.update({key: user})
  1000. user_counter += 1
  1001. else:
  1002. partly_successful_flag = True
  1003.  
  1004. ldap_objects.update(pldap.groups)
  1005.  
  1006. sql.get_objects(connector["ldap_id"])
  1007. sql_objects = {}
  1008. sql_objects.update(sql.objects)
  1009.  
  1010. if options.SetLdapOgid:
  1011. cix += 1
  1012. for o in sql.InitialSqlObjects:
  1013. for k,v in ldap_objects.items():
  1014. if o.has_key("user_dn"):
  1015. if ldap_objects[k]["obj_dn"] == o["user_dn"]:
  1016. log = sql.set_ldapogid(k, o["user_dn"], 0, debug)
  1017. if log.has_key("log") and not debug:
  1018. LOGGER(log["log"],log_handler)
  1019.  
  1020. if debug:
  1021. LOGGER(log["debug"],log_handler)
  1022. else:
  1023. if ldap_objects[k]["obj_dn"] == o["group_dn"]:
  1024. log = sql.set_ldapogid(k, o["group_dn"], 1, debug)
  1025. if log.has_key("log") and not debug:
  1026. LOGGER(log["log"],log_handler)
  1027.  
  1028. if debug:
  1029. LOGGER(log["debug"],log_handler)
  1030.  
  1031. if cix == len(sql.connectors):
  1032. sql.db.commit()
  1033. LOGGER("\n\nLdapOgids were fixed please run sync again without \"--SetLdapOgid\" option", log_handler)
  1034. sys.exit()
  1035. else:
  1036. continue
  1037.  
  1038. for k,v in sql_objects.items():
  1039. if not ldap_objects.has_key(k):
  1040. log = sql.del_object(sql_objects[k], debug)
  1041.  
  1042. if log.has_key("log") and not debug:
  1043. LOGGER(log["log"],log_handler)
  1044.  
  1045. if debug:
  1046. LOGGER(log["debug"],log_handler)
  1047.  
  1048. for k,v in ldap_objects.items():
  1049. if not sql_objects.has_key(k):
  1050. log = sql.add_object(ldap_objects[k], k, connector["ldap_id"], debug,ldap_objects[k]["isgroup"])
  1051.  
  1052. if log.has_key("log") and not debug:
  1053. LOGGER(log["log"],log_handler)
  1054.  
  1055. if debug:
  1056. if log.has_key("debug"):
  1057. LOGGER(log["debug"],log_handler)
  1058.  
  1059. else:
  1060. log = sql.update_object(ldap_objects[k], k, connector["ldap_id"], debug,ldap_objects[k]["isgroup"])
  1061.  
  1062. if log.has_key("log") and not debug:
  1063. LOGGER(log["log"],log_handler)
  1064.  
  1065. if debug:
  1066. if log.has_key("debug"):
  1067. LOGGER(log["debug"],log_handler)
  1068.  
  1069. ### Building LDAP Group and User memberships
  1070. if ldap_objects[k]["isgroup"]:
  1071. if ldap_objects[k].has_key("member"):
  1072. ldap_memberShip[ldap_objects[k]["obj_dn"]] = ldap_objects[k]["member"]
  1073. else:
  1074. if ldap_objects[k].has_key("memberOf"):
  1075. for groupDN in list(ldap_objects[k]["memberOf"]):
  1076. if ldap_memberShip.has_key(groupDN):
  1077. ldap_memberShip[groupDN].add(ldap_objects[k]["obj_dn"])
  1078.  
  1079. else:
  1080. tmp_set = set()
  1081. tmp_set.add(ldap_objects[k]["obj_dn"])
  1082. ldap_memberShip[groupDN] = tmp_set
  1083.  
  1084. sql.build_DN2OID(connector["ldap_id"])
  1085. sql.buid_membership()
  1086.  
  1087. for groupDN,members in sql.memberShip.items():
  1088. if ldap_memberShip.has_key(groupDN):
  1089. if len(members.difference(ldap_memberShip[groupDN])):
  1090. isgroup = False
  1091. for member in list(members.difference(ldap_memberShip[groupDN])):
  1092. if sql.user_DN2OID.has_key(member) and sql.group_DN2OID.has_key(groupDN):
  1093. #LOGGER("Removing user (%s) from group (%s)" % (member, sql.group_DN2OID[groupDN]), log_handler)
  1094. LOGGER("Removing user [%s](OID: %s) to group [%s](GID: %s)" % (member, sql.user_DN2OID[member],
  1095. groupDN, sql.group_DN2OID[groupDN]),log_handler)
  1096. sql.del_object2group(sql.user_DN2OID[member], sql.group_DN2OID[groupDN], isgroup, debug)
  1097. if sql.group_DN2OID.has_key(member) and sql.group_DN2OID.has_key(groupDN):
  1098. isgroup = True
  1099. #LOGGER("Removing group (%s) from group (%s)" % (member, sql.group_DN2OID[groupDN]), log_handler)
  1100. LOGGER("Removing group [%s](GID: %s) from group [%s](GID: %s)" %(member, sql.group_DN2OID[member],
  1101. groupDN, sql.group_DN2OID[groupDN]),log_handler)
  1102. sql.del_object2group(sql.group_DN2OID[member], sql.group_DN2OID[groupDN] ,isgroup, debug)
  1103.  
  1104. for groupDN,members in ldap_memberShip.items():
  1105. if not sql.memberShip.has_key(groupDN):
  1106. for member in list(members):
  1107. isgroup = False
  1108. if sql.user_DN2OID.has_key(member) and sql.group_DN2OID.has_key(groupDN):
  1109. #LOGGER("Adding User(DN): %s to group (%s) " % (sql.user_DN2OID[member],sql.group_DN2OID[groupDN]),log_handler)
  1110. LOGGER("Adding User(DN): [%s](OID: %s) to group [%s](GID: %s)" % (member, sql.user_DN2OID[member],
  1111. groupDN, sql.group_DN2OID[groupDN]),log_handler)
  1112. sql.add_object2group(sql.user_DN2OID[member], sql.group_DN2OID[groupDN], isgroup, debug)
  1113. if sql.group_DN2OID.has_key(member) and sql.group_DN2OID.has_key(groupDN):
  1114. isgroup = True
  1115. #LOGGER("Adding Group(DN): %s to group (%s) " % (sql.group_DN2OID[member],sql.group_DN2OID[groupDN]),log_handler)
  1116. LOGGER("Adding Group(DN): [%s](GID: %s) to group [%s](GID: %s)" % (member, sql.group_DN2OID[member],
  1117. groupDN, sql.group_DN2OID[groupDN]),log_handler)
  1118. sql.add_object2group(sql.group_DN2OID[member], sql.group_DN2OID[groupDN], isgroup, debug)
  1119. else:
  1120. if len(members.difference(sql.memberShip[groupDN])):
  1121. for member in list(members.difference(sql.memberShip[groupDN])):
  1122. isgroup = False
  1123. if sql.user_DN2OID.has_key(member) and sql.group_DN2OID.has_key(groupDN):
  1124. #LOGGER("Adding (update) User(DN): %s to group (%s) " % (member,sql.group_DN2OID[groupDN]),log_handler)
  1125. LOGGER("Adding (update) User(DN): [%s](OID: %s) to group [%s](GID: %s)"% (member, sql.user_DN2OID[member],
  1126. groupDN, sql.group_DN2OID[groupDN]),log_handler)
  1127. sql.add_object2group(sql.user_DN2OID[member], sql.group_DN2OID[groupDN], isgroup, debug)
  1128. if sql.group_DN2OID.has_key(member) and sql.group_DN2OID.has_key(groupDN):
  1129. isgroup = True
  1130. #LOGGER("Adding (update) Group(DN): %s to group (%s) " % (member,sql.group_DN2OID[groupDN]),log_handler)
  1131. LOGGER("Adding (update) Group(DN): [%s](GID: %s) to group [%s](GID: %s)" % (member, sql.group_DN2OID[member],
  1132. groupDN, sql.group_DN2OID[groupDN]),log_handler)
  1133. sql.add_object2group(sql.group_DN2OID[member], sql.group_DN2OID[groupDN], isgroup, debug)
  1134.  
  1135. sql.db.commit()
  1136. for cmd in DbInc.PostSyncActions["CMDS"]:
  1137. runsystemcmd(cmd, debug, log_handler)
  1138.  
  1139. if debug:
  1140. LOGGER("END",log_handler)
  1141.  
  1142. if partly_successful_flag:
  1143. sys.exit(11)
  1144.  
  1145. if __name__ == "__main__":
  1146. sys.exit(main())
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!