def execute(*args, **kw): auth = Auth() log.debug(_("Listing domains..."), level=5) start_time = time.time() domains = auth.list_domains() end_time = time.time() log.debug( _("Found %d domains in %d seconds") % ( len(domains), (end_time-start_time) ), level=8 ) all_folders = [] for primary_domain,secondary_domains in domains: log.debug(_("Running for domain %s") % (primary_domain), level=8) auth.connect(primary_domain) start_time = time.time() auth.synchronize() end_time = time.time() log.info(_("Synchronizing users for %s took %d seconds") % (primary_domain, (end_time-start_time)) )
def execute(*args, **kw): """ List deleted mailboxes """ imap = IMAP() imap.connect() auth = Auth() auth.connect() domains = auth.list_domains() folders = [] for domain in list(set(domains.keys())): folders.extend(imap.lm("DELETED/*@%s" % (domain))) folders.extend(imap.lm("DELETED/*")) print "Deleted folders:" for folder in folders: utf8_folder = imap_utf7.decode(folder).encode('utf-8') mbox_parts = imap.parse_mailfolder(utf8_folder) ts = datetime.datetime.fromtimestamp(int(mbox_parts['hex_timestamp'], 16)) if not conf.raw: print "%s (Deleted at %s)" % (utf8_folder, ts) else: print "%s (Deleted at %s)" % (folder, ts)
def execute(*args, **kw): global imap, pool auth = Auth() log.debug(_("Listing domains..."), level=5) start_time = time.time() domains = auth.list_domains() end_time = time.time() log.debug( _("Found %d domains in %d seconds") % ( len(domains), (end_time-start_time) ), level=8 ) if version.StrictVersion(sys.version[:3]) >= version.StrictVersion("2.7"): pool = multiprocessing.Pool(conf.threads, worker_process, (), 1) else: pool = multiprocessing.Pool(conf.threads, worker_process, ()) for primary_domain in list(set(domains.values())): log.debug(_("Running for domain %s") % (primary_domain), level=8) auth = Auth(primary_domain) auth.connect(primary_domain) start_time = time.time() auth.synchronize(mode='_paged_search', callback=queue_add) end_time = time.time() log.info(_("Synchronizing users for %s took %d seconds") % (primary_domain, (end_time-start_time)) ) while not pool._taskqueue.empty(): time.sleep(1)
def execute(*args, **kw): """ List deleted mailboxes """ try: domain = conf.cli_args.pop(0) except: domain = utils.ask_question(_("Domain")) imap = IMAP() imap.connect() auth = Auth() auth.connect() domains = auth.list_domains() folders = [] for primary,secondaries in domains: if not domain == primary and not domain in secondaries: continue folders.extend(imap.lm("user/%%@%s" % (primary))) for secondary in secondaries: folders.extend(imap.lm("user/%%@%s" % (secondary))) print "Deleted folders:" for folder in folders: if not conf.raw: print imap_utf7.decode(folder) else: print folder
def execute(*args, **kw): """ List deleted mailboxes """ try: domain = conf.cli_args.pop(0) except: domain = utils.ask_question(_("Domain")) imap = IMAP() imap.connect() auth = Auth() auth.connect() domains = auth.list_domains() folders = [] for primary,secondaries in domains: if not domain == primary and not domain in secondaries: continue folders.extend(imap.lm("user/%%@%s" % (primary))) for secondary in secondaries: folders.extend(imap.lm("user/%%@%s" % (secondary))) print "Deleted folders:" for folder in folders: if not conf.raw: print imap_utf7.decode(folder) else: print folder
def execute(*args, **kw): """ List deleted mailboxes """ imap = IMAP() imap.connect() auth = Auth() auth.connect() domains = auth.list_domains() folders = [] for domain in list(set(domains.keys())): folders.extend(imap.lm("DELETED/*@%s" % (domain))) folders.extend(imap.lm("DELETED/*")) print "Deleted folders:" for folder in folders: mbox_parts = imap.parse_mailfolder(folder) if not conf.raw: print "%s (Deleted at %s)" % (imap_utf7.decode(folder).encode('utf-8'), datetime.datetime.fromtimestamp(int(mbox_parts['hex_timestamp'], 16))) else: print "%s (Deleted at %s)" % (folder, datetime.datetime.fromtimestamp(int(mbox_parts['hex_timestamp'], 16)))
def do_sync(self): domain_auth = {} pid = os.getpid() primary_domain = conf.get('kolab', 'primary_domain') while 1: primary_auth = Auth(primary_domain) log.debug(_("Listing domains..."), level=5) start = time.time() try: domains = primary_auth.list_domains() except: time.sleep(60) continue # domains now is a list of tuples, we want the primary_domains primary_domains = [] for primary_domain, secondary_domains in domains: primary_domains.append(primary_domain) # Now we can check if any changes happened. added_domains = [] removed_domains = [] all_domains = set(primary_domains + domain_auth.keys()) for domain in all_domains: if domain in domain_auth.keys() and domain in primary_domains: if not domain_auth[domain].is_alive(): domain_auth[domain].terminate() added_domains.append(domain) else: continue elif domain in domain_auth.keys(): removed_domains.append(domain) else: added_domains.append(domain) if len(removed_domains) == 0 and len(added_domains) == 0: 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()
def execute(*args, **kw): """ Synchronize or display changes """ imap = IMAP() if not conf.connect_server == None: imap.connect(server=conf.connect_server) else: imap.connect() auth = Auth() auth.connect() domains = auth.list_domains() folders = imap.lm() imap_domains_not_domains = [] for folder in folders: if len(folder.split('@')) > 1 and not folder.startswith('DELETED'): _folder_domain = folder.split('@')[-1] if not _folder_domain in list(set(domains.keys() + domains.values())): imap_domains_not_domains.append(folder.split('@')[-1]) imap_domains_not_domains = list(set(imap_domains_not_domains)) log.debug(_("Domains in IMAP not in LDAP: %r") % (imap_domains_not_domains), level=8) if len(imap_domains_not_domains) > 0: for domain in imap_domains_not_domains: folders = [] folders.extend(imap.lm('shared/%%@%s' % (domain))) folders.extend(imap.lm('user/%%@%s' % (domain))) for folder in folders: if conf.delete: if conf.dry_run: if not folder.split('/')[0] == 'shared': log.warning(_("No recipients for '%s' (would have deleted the mailbox if not for --dry-run)!") % ('/'.join(folder.split('/')[1:]))) else: continue else: if not '/'.join(folder.split('/')[0]) == 'shared': log.info(_("Deleting mailbox '%s' because it has no recipients") % (folder)) try: imap.dm(folder) except Exception, errmsg: log.error(_("An error occurred removing mailbox %r: %r") % (folder, errmsg)) else: log.info(_("Not automatically deleting shared folder '%s'") % (folder)) else: log.warning(_("No recipients for '%s' (use --delete to delete)!") % ('/'.join(folder.split('/')[1:])))
def expand_mydomains(): """ Return a list of my domains. """ auth = Auth() auth.connect() mydomains = [] _mydomains = auth.list_domains() for primary, secondaries in _mydomains: mydomains.append(primary) for secondary in secondaries: mydomains.append(secondary) return mydomains
def execute(*args, **kw): """ List deleted mailboxes """ imap = IMAP() imap.connect() auth = Auth() auth.connect() domains = auth.list_domains() folders = [] for domain in domains.keys(): print "%s: %d" % (domain,len(imap.lm("user/%%@%s" % (domain)))) null_realm = len(imap.lm("user/%%")) if null_realm > 0: print "null: %d" % (null_realm)
def execute(*args, **kw): """ List deleted mailboxes """ imap = IMAP() imap.connect() auth = Auth() auth.connect() domains = auth.list_domains() folders = [] for domain in domains.keys(): print "%s: %d" % (domain, len(imap.lm("user/%%@%s" % (domain)))) null_realm = len(imap.lm("user/%%")) if null_realm > 0: print "null: %d" % (null_realm)
def verify_domain(domain): """ Verify whether the domain is internal (mine) or external. """ auth = Auth() auth.connect() domain_verified = False _mydomains = auth.list_domains() for primary, secondaries in _mydomains: if primary == domain: domain_verified = True elif domain in secondaries: domain_verified = True if domain_verified == None: domain_verified = False return domain_verified
def resource_record_from_email_address(email_address): """ Resolves the given email address to a resource entity """ global auth if not auth: auth = Auth() auth.connect() resource_records = [] local_domains = auth.list_domains() if not local_domains == None: local_domains = list(set(local_domains.keys())) if not email_address.split('@')[1] in local_domains: return [] log.debug( _("Checking if email address %r belongs to a resource (collection)") % (email_address), level=8 ) resource_records = auth.find_resource(email_address) if isinstance(resource_records, list): if len(resource_records) > 0: log.debug(_("Resource record(s): %r") % (resource_records), level=8) else: log.debug(_("No resource (collection) records found for %r") % (email_address), level=9) elif isinstance(resource_records, basestring): resource_records = [ resource_records ] log.debug(_("Resource record: %r") % (resource_records), level=8) return resource_records
def user_dn_from_email_address(email_address): """ Resolves the given email address to a Kolab user entity """ global auth if not auth: auth = Auth() auth.connect() # return cached value if user_dn_from_email_address.cache.has_key(email_address): return user_dn_from_email_address.cache[email_address] local_domains = auth.list_domains() if not local_domains == None: local_domains = list(set(local_domains.keys())) if not email_address.split('@')[1] in local_domains: user_dn_from_email_address.cache[email_address] = None return None log.debug(_("Checking if email address %r belongs to a local user") % (email_address), level=8) user_dn = auth.find_user_dn(email_address, True) if isinstance(user_dn, basestring): log.debug(_("User DN: %r") % (user_dn), level=8) else: log.debug(_("No user record(s) found for %r") % (email_address), level=9) # remember this lookup user_dn_from_email_address.cache[email_address] = user_dn return user_dn
def execute(*args, **kw): global imap, pool auth = Auth() if conf.domain == "all": log.debug(_("Listing domains..."), level=5) start_time = time.time() domains = auth.list_domains() end_time = time.time() log.debug(_("Found %d domains in %d seconds") % (len(domains), (end_time - start_time)), level=8) else: domains = {} domains[conf.domain] = conf.domain if version.StrictVersion(sys.version[:3]) >= version.StrictVersion("2.7"): pool = multiprocessing.Pool(conf.threads, worker_process, (), 1) else: pool = multiprocessing.Pool(conf.threads, worker_process, ()) for primary_domain in list(set(domains.values())): log.debug(_("Running for domain %s") % (primary_domain), level=8) auth = Auth(primary_domain) auth.connect(primary_domain) start_time = time.time() auth.synchronize(mode='_paged_search', callback=queue_add) end_time = time.time() log.info( _("Synchronizing users for %s took %d seconds") % (primary_domain, (end_time - start_time))) while not pool._taskqueue.empty(): time.sleep(1)
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]
def execute(*args, **kw): try: primary_rcpt_address = conf.cli_args.pop(0) try: secondary_rcpt_address = conf.cli_args.pop(0) except: print >> sys.stderr, _("Specify the (new) alias address") sys.exit(1) except: print >> sys.stderr, _("Specify the existing recipient address") sys.exit(1) if len(primary_rcpt_address.split('@')) > 1: primary_rcpt_domain = primary_rcpt_address.split('@')[-1] else: primary_rcpt_domain = conf.get('kolab', 'primary_domain') auth = Auth(domain=primary_rcpt_domain) domains = auth.list_domains() #print domains if len(secondary_rcpt_address.split('@')) > 1: secondary_rcpt_domain = secondary_rcpt_address.split('@')[-1] else: secondary_rcpt_domain = conf.get('kolab', 'primary_domain') # Check if either is in fact a domain if not primary_rcpt_domain.lower() in domains.keys(): print >> sys.stderr, _("Domain %r is not a local domain") % ( primary_rcpt_domain) sys.exit(1) if not secondary_rcpt_domain.lower() in domains.keys(): print >> sys.stderr, _("Domain %r is not a local domain") % ( secondary_rcpt_domain) sys.exit(1) if not primary_rcpt_domain == secondary_rcpt_domain: if not domains[primary_rcpt_domain] == domains[secondary_rcpt_domain]: print >> sys.stderr, _( "Primary and secondary domain do not have the same parent domain" ) sys.exit(1) primary_recipient_dn = auth.find_recipient(primary_rcpt_address) if primary_recipient_dn == [] or len(primary_recipient_dn) == 0: print >> sys.stderr, _("No such recipient %r") % (primary_rcpt_address) sys.exit(1) secondary_recipient_dn = auth.find_recipient(secondary_rcpt_address) if not secondary_recipient_dn == [] and not len( secondary_recipient_dn) == 0: print >> sys.stderr, _("Recipient for alias %r already exists") % ( secondary_rcpt_address) sys.exit(1) rcpt_attrs = conf.get_list('ldap', 'mail_attributes') primary_rcpt_attr = rcpt_attrs[0] if len(rcpt_attrs) >= 2: secondary_rcpt_attr = rcpt_attrs[1] else: print >> sys.stderr, _("Environment is not configured for " + \ "users to hold secondary mail attributes") sys.exit(1) primary_recipient = auth.get_entry_attributes(primary_rcpt_domain, primary_recipient_dn, rcpt_attrs) if not primary_recipient.has_key(primary_rcpt_attr): print >> sys.stderr, _( "Recipient %r is not the primary recipient for address %r") % ( primary_recipient, primary_rcpt_address) sys.exit(1) if not primary_recipient.has_key(secondary_rcpt_attr): auth.set_entry_attributes( primary_rcpt_domain, primary_recipient_dn, {secondary_rcpt_attr: [secondary_rcpt_address]}) else: if isinstance(primary_recipient[secondary_rcpt_attr], basestring): new_secondary_rcpt_attrs = [ primary_recipient[secondary_rcpt_attr], secondary_rcpt_address ] else: new_secondary_rcpt_attrs = \ primary_recipient[secondary_rcpt_attr] + \ [ secondary_rcpt_address ] auth.set_entry_attributes( primary_rcpt_domain, primary_recipient_dn, {secondary_rcpt_attr: new_secondary_rcpt_attrs})
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 tuples, we want the primary_domains primary_domains = [] for primary_domain in list(set(domains.values())): primary_domains.append(primary_domain) # Now we can check if any changes happened. added_domains = [] removed_domains = [] all_domains = set(primary_domains + domain_auth.keys()) for domain in all_domains: if domain in domain_auth.keys() and domain in primary_domains: if not domain_auth[domain].is_alive(): domain_auth[domain].terminate() added_domains.append(domain) else: continue elif domain in domain_auth.keys(): removed_domains.append(domain) else: 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]
def user_mailbox_create(self, mailbox_base_name, server=None): """ Create a user mailbox. Returns the full path to the new mailbox folder. """ # TODO: Whether or not to lowercase the mailbox name is really up to the # IMAP server setting username_tolower (normalize_uid, lmtp_downcase_rcpt). self.connect() if not mailbox_base_name == mailbox_base_name.lower(): log.warning(_("Downcasing mailbox name %r") % (mailbox_base_name)) mailbox_base_name = mailbox_base_name.lower() folder_name = "user%s%s" % (self.get_separator(), mailbox_base_name) log.info(_("Creating new mailbox for user %s") %(mailbox_base_name)) max_tries = 10 success = False while not success and max_tries > 0: success = self.create_folder(folder_name, server) if not success: self.disconnect() max_tries -= 1 time.sleep(1) self.connect() if not success: log.error(_("Could not create the mailbox for user %s, aborting." % (mailbox_base_name))) return False # In a Cyrus IMAP Murder topology, wait for the murder to have settled if self.imap_murder(): self.disconnect() self.connect() created = False last_log = time.time() while not created: created = self.has_folder(folder_name) if not created: if time.time() - last_log > 5: log.info(_("Waiting for the Cyrus IMAP Murder to settle...")) last_log = time.time() time.sleep(0.5) _additional_folders = None if not hasattr(self, 'domain'): self.domain = None if self.domain == None and len(mailbox_base_name.split('@')) > 1: self.domain = mailbox_base_name.split('@')[1] if not self.domain == None: if conf.has_option(self.domain, "autocreate_folders"): _additional_folders = conf.get_raw( self.domain, "autocreate_folders" ) else: from pykolab.auth import Auth auth = Auth() auth.connect() domains = auth.list_domains(self.domain) auth.disconnect() if len(domains.keys()) > 0: if domains.has_key(self.domain): primary = domains[self.domain] if conf.has_option(primary, "autocreate_folders"): _additional_folders = conf.get_raw( primary, "autocreate_folders" ) if _additional_folders == None: if conf.has_option('kolab', "autocreate_folders"): _additional_folders = conf.get_raw( 'kolab', "autocreate_folders" ) additional_folders = conf.plugins.exec_hook( "create_user_folders", kw={ 'folder': folder_name, 'additional_folders': _additional_folders } ) if not additional_folders == None: self.user_mailbox_create_additional_folders( mailbox_base_name, additional_folders ) if not self.domain == None: if conf.has_option(self.domain, "sieve_mgmt"): sieve_mgmt_enabled = conf.get(self.domain, 'sieve_mgmt') if utils.true_or_false(sieve_mgmt_enabled): conf.plugins.exec_hook( 'sieve_mgmt_refresh', kw={ 'user': mailbox_base_name } ) return folder_name
def execute(*args, **kw): """ Synchronize or display changes """ imap = IMAP() if not conf.connect_server == None: imap.connect(server=conf.connect_server) else: imap.connect() auth = Auth() auth.connect() result_attribute = conf.get('cyrus-sasl', 'result_attribute') if result_attribute is None: result_attribute = 'mail' domains = auth.list_domains() folders = imap.lm() imap_domains_not_domains = [] for folder in folders: if len(folder.split('@')) > 1 and not folder.startswith('DELETED'): _folder_domain = folder.split('@')[-1] if not _folder_domain in list( set(domains.keys() + domains.values())): imap_domains_not_domains.append(folder.split('@')[-1]) imap_domains_not_domains = list(set(imap_domains_not_domains)) log.debug(_("Domains in IMAP not in LDAP: %r") % (imap_domains_not_domains), level=8) if len(imap_domains_not_domains) > 0: for domain in imap_domains_not_domains: folders = [] folders.extend(imap.lm('shared/%%@%s' % (domain))) folders.extend(imap.lm('user/%%@%s' % (domain))) for folder in folders: r_folder = folder if not folder.startswith('shared/'): r_folder = '/'.join(folder.split('/')[1:]) if conf.delete: if conf.dry_run: if not folder.startswith('shared/'): log.warning( _("No recipients for '%s' (would have deleted the mailbox if not for --dry-run)!" ) % (r_folder)) else: continue else: if not folder.startswith('shared/'): log.info( _("Deleting mailbox '%s' because it has no recipients" ) % (folder)) try: imap.dm(folder) except Exception, errmsg: log.error( _("An error occurred removing mailbox %r: %r" ) % (folder, errmsg)) else: log.info( _("Not automatically deleting shared folder '%s'" ) % (folder)) else: log.warning( _("No recipients for '%s' (use --delete to delete)!") % (r_folder))
def execute(*args, **kw): """ List mailboxes """ auth = Auth() domains = auth.list_domains() imap = IMAP() imap.connect() domain_folders = {} subjects = [] # Placeholder for subjects that would have already been deleted subjects_deleted = [] for domain in domains.keys(): domain_folders[domain] = imap.lm("user/%%@%s" % (domain)) for domain in domain_folders.keys(): auth = Auth(domain=domain) auth.connect(domain) for folder in domain_folders[domain]: user = folder.replace('user/', '') try: recipient = auth.find_recipient(user) except ldap.NO_SUCH_OBJECT, errmsg: if not user in subjects_deleted and conf.dryrun: subjects_deleted.append(user) if conf.dryrun: log.info( _("Would have deleted folder 'user/%s' (dryrun)") % (user)) else: log.info(_("Deleting folder 'user/%s'") % (user)) continue if len(recipient) == 0 or recipient == []: if not user in subjects_deleted and conf.dryrun: subjects_deleted.append(user) if conf.dryrun: log.info( _("Would have deleted folder 'user/%s' (dryrun)") % (user)) else: log.info(_("Deleting folder 'user/%s'") % (user)) try: imap.dm(folder) except: log.error( _("Error deleting folder 'user/%s'") % (user)) else: log.debug(_("Valid recipient found for 'user/%s'") % (user), level=6) if not user in subjects: subjects.append(user)
def execute(*args, **kw): try: primary_rcpt_address = conf.cli_args.pop(0) try: secondary_rcpt_address = conf.cli_args.pop(0) except: print >> sys.stderr, _("Specify the (new) alias address") sys.exit(1) except: print >> sys.stderr, _("Specify the existing recipient address") sys.exit(1) if len(primary_rcpt_address.split('@')) > 1: primary_rcpt_domain = primary_rcpt_address.split('@')[-1] else: primary_rcpt_domain = conf.get('kolab', 'primary_domain') auth = Auth(domain=primary_rcpt_domain) domains = auth.list_domains() #print domains if len(secondary_rcpt_address.split('@')) > 1: secondary_rcpt_domain = secondary_rcpt_address.split('@')[-1] else: secondary_rcpt_domain = conf.get('kolab', 'primary_domain') # Check if either is in fact a domain if not primary_rcpt_domain.lower() in domains.keys(): print >> sys.stderr, _("Domain %r is not a local domain") % (primary_rcpt_domain) sys.exit(1) if not secondary_rcpt_domain.lower() in domains.keys(): print >> sys.stderr, _("Domain %r is not a local domain") % (secondary_rcpt_domain) sys.exit(1) if not primary_rcpt_domain == secondary_rcpt_domain: if not domains[primary_rcpt_domain] == domains[secondary_rcpt_domain]: print >> sys.stderr, _("Primary and secondary domain do not have the same parent domain") sys.exit(1) primary_recipient_dn = auth.find_recipient(primary_rcpt_address) if primary_recipient_dn == [] or len(primary_recipient_dn) == 0: print >> sys.stderr, _("No such recipient %r") % (primary_rcpt_address) sys.exit(1) secondary_recipient_dn = auth.find_recipient(secondary_rcpt_address) if not secondary_recipient_dn == [] and not len(secondary_recipient_dn) == 0: print >> sys.stderr, _("Recipient for alias %r already exists") % (secondary_rcpt_address) sys.exit(1) rcpt_attrs = conf.get_list('ldap', 'mail_attributes') primary_rcpt_attr = rcpt_attrs[0] if len(rcpt_attrs) >= 2: secondary_rcpt_attr = rcpt_attrs[1] else: print >> sys.stderr, _("Environment is not configured for " + \ "users to hold secondary mail attributes") sys.exit(1) primary_recipient = auth.get_entry_attributes(primary_rcpt_domain, primary_recipient_dn, rcpt_attrs) if not primary_recipient.has_key(primary_rcpt_attr): print >> sys.stderr, _("Recipient %r is not the primary recipient for address %r") % (primary_recipient, primary_rcpt_address) sys.exit(1) if not primary_recipient.has_key(secondary_rcpt_attr): auth.set_entry_attributes(primary_rcpt_domain, primary_recipient_dn, {secondary_rcpt_attr: [ secondary_rcpt_address ] }) else: if isinstance(primary_recipient[secondary_rcpt_attr], basestring): new_secondary_rcpt_attrs = [ primary_recipient[secondary_rcpt_attr], secondary_rcpt_address ] else: new_secondary_rcpt_attrs = \ primary_recipient[secondary_rcpt_attr] + \ [ secondary_rcpt_address ] auth.set_entry_attributes( primary_rcpt_domain, primary_recipient_dn, { secondary_rcpt_attr: new_secondary_rcpt_attrs } )