# -*- coding: UTF-8 -*-
# Copyright (c) 2012 - 2014, martin f. krafft
# See COPYING for distribution information.
"""
VirtualMailManager.catchall
~~~~~~~~~~~~~~~~~~~~~~~~~~~
Virtual Mail Manager's CatchallAlias class to manage domain catch-all
aliases.
This is heavily based on (more or less a copy of) the Alias class, because
fundamentally, catchall aliases are aliases, but without a localpart.
While Alias could potentially derive from CatchallAlias to reuse some of
the functionality, it's probably not worth it. I found no sensible way to
derive CatchallAlias from Alias, or at least none that would harness the
powers of polymorphism.
Yet, we reuse the AliasError exception class, which makes sense.
"""
from VirtualMailManager.domain import get_gid
from VirtualMailManager.emailaddress import \
EmailAddress, DestinationEmailAddress as DestAddr
from VirtualMailManager.errors import AliasError as AErr
from VirtualMailManager.ext.postconf import Postconf
from VirtualMailManager.constants import \
ALIAS_EXCEEDS_EXPANSION_LIMIT, NO_SUCH_ALIAS, NO_SUCH_DOMAIN
_ = lambda msg: msg
cfg_dget = lambda option: None
class CatchallAlias(object):
"""Class to manage domain catch-all aliases."""
__slots__ = ('_domain', '_dests', '_gid', '_dbh')
def __init__(self, dbh, domain):
self._domain = domain
self._dbh = dbh
self._gid = get_gid(self._dbh, self.domain)
if not self._gid:
raise AErr(_("The domain '%s' does not exist.") %
self.domain, NO_SUCH_DOMAIN)
self._dests = []
self._load_dests()
def _load_dests(self):
"""Loads all known destination addresses into the _dests list."""
dbc = self._dbh.cursor()
dbc.execute('SELECT destination FROM catchall WHERE gid = %s',
(self._gid,))
dests = dbc.fetchall()
if dbc.rowcount > 0:
self._dests.extend(DestAddr(dest[0], self._dbh) for dest in dests)
dbc.close()
def _check_expansion(self, count_new):
"""Checks the current expansion limit of the alias."""
postconf = Postconf(cfg_dget('bin.postconf'))
limit = int(postconf.read('virtual_alias_expansion_limit'))
dcount = len(self._dests)
failed = False
if dcount == limit or dcount + count_new > limit:
failed = True
errmsg = _(
"""Cannot add %(count_new)i new destination(s) to catch-all alias for
domain '%(domain)s'. Currently this alias expands into %(count)i/%(limit)i
recipients. %(count_new)i additional destination(s) will render this alias
unusable.
Hint: Increase Postfix' virtual_alias_expansion_limit""")
elif dcount > limit:
failed = True
errmsg = _(
"""Cannot add %(count_new)i new destination(s) to catch-all alias for domain
'%(domain)s'. This alias already exceeds its expansion limit \
(%(count)i/%(limit)i).
So its unusable, all messages addressed to this alias will be bounced.
Hint: Delete some destination addresses.""")
if failed:
raise AErr(errmsg % {'domain': self._domain, 'count': dcount,
'limit': limit, 'count_new': count_new},
ALIAS_EXCEEDS_EXPANSION_LIMIT)
def _delete(self, destinations=None):
"""Delete one ore multiple destinations from the catchall alias, if
``destinations`` is not ``None``. If ``destinations`` is None, the
catchall alias with all its destination addresses will be deleted.
"""
dbc = self._dbh.cursor()
if not destinations:
dbc.execute('DELETE FROM catchall WHERE gid = %s', (self._gid,))
else:
dbc.executemany('DELETE FROM catchall WHERE gid = %d AND '
'destination = %%s' % self._gid,
((str(dest),) for dest in destinations))
if dbc.rowcount > 0:
self._dbh.commit()
dbc.close()
def __len__(self):
"""Returns the number of destinations of the catchall alias."""
return len(self._dests)
@property
def domain(self):
"""The Alias' domain."""
return self._domain
def add_destinations(self, destinations, warnings=None):
"""Adds the `EmailAddress`es from *destinations* list to the
destinations of the catchall alias.
Destinations, that are already assigned to the alias, will be
removed from *destinations*. When done, this method will return
a set with all destinations, that were saved in the database.
"""
destinations = set(destinations)
assert destinations and \
all(isinstance(dest, EmailAddress) for dest in destinations)
if not warnings is None:
assert isinstance(warnings, list)
duplicates = destinations.intersection(set(self._dests))
if duplicates:
destinations.difference_update(set(self._dests))
if not warnings is None:
warnings.extend(duplicates)
if not destinations:
return destinations
self._check_expansion(len(destinations))
dbc = self._dbh.cursor()
dbc.executemany("INSERT INTO catchall (gid, destination) "
"VALUES (%d, %%s)" % self._gid,
((str(destination),) for destination in destinations))
self._dbh.commit()
dbc.close()
self._dests.extend(destinations)
return destinations
def del_destinations(self, destinations, warnings=None):
"""Deletes the specified ``destinations`` from the catchall alias."""
destinations = set(destinations)
assert destinations and \
all(isinstance(dest, EmailAddress) for dest in destinations)
if not warnings is None:
assert isinstance(warnings, list)
if not self._dests:
raise AErr(_("There are no catch-all aliases defined for "
"domain '%s'.") % self._domain, NO_SUCH_ALIAS)
unknown = destinations.difference(set(self._dests))
if unknown:
destinations.intersection_update(set(self._dests))
if not warnings is None:
warnings.extend(unknown)
if not destinations:
raise AErr(_("No suitable destinations left to remove from the "
"catch-all alias of domain '%s'.") % self._domain,
NO_SUCH_ALIAS)
self._delete(destinations)
for destination in destinations:
self._dests.remove(destination)
def get_destinations(self):
"""Returns an iterator for all destinations of the catchall alias."""
if not self._dests:
raise AErr(_("There are no catch-all aliases defined for "
"domain '%s'.") % self._domain, NO_SUCH_ALIAS)
return iter(self._dests)
def delete(self):
"""Deletes all catchall destinations for the domain."""
if not self._dests:
raise AErr(_("There are no catch-all aliases defined for "
"domain '%s'.") % self._domain, NO_SUCH_ALIAS)
self._delete()
del self._dests[:]
del _, cfg_dget