def do_sync(self):
domain_auth = {}
pid = os.getpid()
primary_domain = conf.get('kolab', 'primary_domain')
while 1:
primary_auth = Auth(primary_domain)
connected = False
while not connected:
try:
primary_auth.connect()
connected = True
except Exception, errmsg:
connected = False
log.error(_("Could not connect to LDAP, is it running?"))
time.sleep(5)
log.debug(_("Listing domains..."), level=5)
start = time.time()
try:
domains = primary_auth.list_domains()
except:
time.sleep(60)
continue
if isinstance(domains, list) and len(domains) < 1:
log.error(_("No domains. Not syncing"))
time.sleep(5)
continue
# domains now is a list of key-valye pairs in the format of
# {'secondary': 'primary'}, we want the primaries
primaries = list(set(domains.values()))
# Store the naming contexts for the domains as
#
# {'domain': 'naming context'}
#
# and the domain root dns as
#
# {'domain': 'domain root dn'}
#
domain_root_dns = {}
naming_contexts = {}
for primary in primaries:
naming_context = primary_auth.domain_naming_context(primary)
domain_root_dn = primary_auth._auth._kolab_domain_root_dn(
primary)
log.debug(_("Domain %r naming context: %r, root dn: %r") %
(primary, naming_context, domain_root_dn),
level=8)
domain_root_dns[primary] = domain_root_dn
naming_contexts[primary] = naming_context
log.debug(_("Naming contexts to synchronize: %r") %
(list(set(naming_contexts.values()))),
level=8)
# Find however many naming contexts we have, and what the
# corresponding domain name is for them.
primary_domains = [
x for x, y in naming_contexts.iteritems()
if domain_root_dns[x] == y
]
# Now we can check if any changes happened.
added_domains = []
removed_domains = []
# Combine the domains from LDAP with the domain processes
# accounted for locally.
all_domains = list(set(primary_domains + domain_auth.keys()))
log.debug(_("Result set of domains: %r") % (all_domains), level=8)
for domain in all_domains:
log.debug(_("Checking for domain %s") % (domain), level=8)
if domain in domain_auth.keys() and domain in primary_domains:
if not domain_auth[domain].is_alive():
log.debug(_("Domain %s isn't alive anymore.") %
(domain),
level=8)
domain_auth[domain].terminate()
added_domains.append(domain)
else:
log.debug(_("Domain %s already there and alive.") %
(domain),
level=8)
continue
elif domain in domain_auth.keys():
log.debug(_("Domain %s should not exist any longer.") %
(domain),
level=8)
removed_domains.append(domain)
else:
log.debug(_("Domain %s does not have a process yet.") %
(domain),
level=8)
added_domains.append(domain)
if len(removed_domains) == 0 and len(added_domains) == 0:
try:
sleep_between_domain_operations_in_seconds = (float)(
conf.get('kolab', 'domain_sync_interval'))
time.sleep(sleep_between_domain_operations_in_seconds)
except ValueError:
time.sleep(600)
log.debug(_("added domains: %r, removed domains: %r") %
(added_domains, removed_domains),
level=8)
for domain in added_domains:
domain_auth[domain] = Process(domain)
domain_auth[domain].start()
# Pause or hammer your LDAP server to death
if len(added_domains) >= 5:
time.sleep(10)
for domain in removed_domains:
domain_auth[domain].terminate()
del domain_auth[domain]
