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
}
)
