# -*- coding: UTF-8 -*-

# Copyright (c) 2007 - 2011, Pascal Volk

# See COPYING for distribution information.

"""

   VirtualMailManager.handler

   ~~~~~~~~~~~~~~~~~~~~~~~~~~

   A wrapper class. It wraps round all other classes and does some

   dependencies checks.

   Additionally it communicates with the PostgreSQL database, creates

   or deletes directories of domains or users.

"""

import os

import re

from shutil import rmtree

from subprocess import Popen, PIPE

from VirtualMailManager.account import Account

from VirtualMailManager.alias import Alias

from VirtualMailManager.aliasdomain import AliasDomain

from VirtualMailManager.common import exec_ok, lisdir

from VirtualMailManager.config import Config as Cfg

from VirtualMailManager.constants import MIN_GID, MIN_UID, \

     ACCOUNT_EXISTS, ALIAS_EXISTS, CONF_NOFILE, CONF_NOPERM, CONF_WRONGPERM, \

     DATABASE_ERROR, DOMAINDIR_GROUP_MISMATCH, DOMAIN_INVALID, \

     FOUND_DOTS_IN_PATH, INVALID_ARGUMENT, MAILDIR_PERM_MISMATCH, \

     NOT_EXECUTABLE, NO_SUCH_ACCOUNT, NO_SUCH_ALIAS, NO_SUCH_BINARY, \

     NO_SUCH_DIRECTORY, NO_SUCH_RELOCATED, RELOCATED_EXISTS, VMM_ERROR

from VirtualMailManager.domain import Domain, get_gid

from VirtualMailManager.emailaddress import DestinationEmailAddress, \

     EmailAddress

from VirtualMailManager.errors import \

     DomainError, NotRootError, PermissionError, VMMError

from VirtualMailManager.mailbox import new as new_mailbox

from VirtualMailManager.pycompat import all, any

from VirtualMailManager.relocated import Relocated

from VirtualMailManager.transport import Transport

_ = lambda msg: msg

_db_mod = None

CFG_FILE = 'vmm.cfg'

CFG_PATH = '/root:/usr/local/etc:/etc'

RE_DOMAIN_SEARCH = """^[a-z0-9-\.]+$"""

TYPE_ACCOUNT = 0x1

TYPE_ALIAS = 0x2

TYPE_RELOCATED = 0x4

OTHER_TYPES = {

    TYPE_ACCOUNT: (_(u'an account'), ACCOUNT_EXISTS),

    TYPE_ALIAS: (_(u'an alias'), ALIAS_EXISTS),

    TYPE_RELOCATED: (_(u'a relocated user'), RELOCATED_EXISTS),

}

class Handler(object):

    """Wrapper class to simplify the access on all the stuff from

    VirtualMailManager"""

    __slots__ = ('_cfg', '_cfg_fname', '_db_connect', '_dbh', '_warnings')

    def __init__(self, skip_some_checks=False):

        """Creates a new Handler instance.

        ``skip_some_checks`` : bool

            When a derived class knows how to handle all checks this

            argument may be ``True``. By default it is ``False`` and

            all checks will be performed.

        Throws a NotRootError if your uid is greater 0.

        """

        self._cfg_fname = ''

        self._warnings = []

        self._cfg = None

        self._dbh = None

        self._db_connect = None

        if os.geteuid():

            raise NotRootError(_(u"You are not root.\n\tGood bye!\n"),

                               CONF_NOPERM)

        if self._check_cfg_file():

            self._cfg = Cfg(self._cfg_fname)

            self._cfg.load()

        if not skip_some_checks:

            self._cfg.check()

            self._chkenv()

            self._set_db_connect()

    def _find_cfg_file(self):

        """Search the CFG_FILE in CFG_PATH.

        Raise a VMMError when no vmm.cfg could be found.

        """

        for path in CFG_PATH.split(':'):

            tmp = os.path.join(path, CFG_FILE)

            if os.path.isfile(tmp):

                self._cfg_fname = tmp

                break

        if not self._cfg_fname:

            raise VMMError(_(u"Could not find '%(cfg_file)s' in: "

                             u"'%(cfg_path)s'") % {'cfg_file': CFG_FILE,

                           'cfg_path': CFG_PATH}, CONF_NOFILE)

    def _check_cfg_file(self):

        """Checks the configuration file, returns bool"""

        self._find_cfg_file()

        fstat = os.stat(self._cfg_fname)

        fmode = int(oct(fstat.st_mode & 0777))

        if fmode % 100 and fstat.st_uid != fstat.st_gid or \

           fmode % 10 and fstat.st_uid == fstat.st_gid:

            raise PermissionError(_(u"wrong permissions for '%(file)s': "

                                    u"%(perms)s\n`chmod 0600 %(file)s` would "

                                    u"be great.") % {'file': self._cfg_fname,

                                  'perms': fmode}, CONF_WRONGPERM)

        else:

            return True

    def _chkenv(self):

        """Make sure our base_directory is a directory and that all

        required executables exists and are executable.

        If not, a VMMError will be raised"""

        dir_created = False

        basedir = self._cfg.dget('misc.base_directory')

        if not os.path.exists(basedir):

            old_umask = os.umask(0006)

            os.makedirs(basedir, 0771)

            os.chown(basedir, 0, 0)

            os.umask(old_umask)

            dir_created = True

        if not dir_created and not lisdir(basedir):

            raise VMMError(_(u"'%(path)s' is not a directory.\n(%(cfg_file)s: "

                             u"section 'misc', option 'base_directory')") %

                           {'path': basedir, 'cfg_file': self._cfg_fname},

                           NO_SUCH_DIRECTORY)

        for opt, val in self._cfg.items('bin'):

            try:

                exec_ok(val)

            except VMMError, err:

                if err.code in (NO_SUCH_BINARY, NOT_EXECUTABLE):

                    raise VMMError(err.msg + _(u"\n(%(cfg_file)s: section "

                                   u"'bin', option '%(option)s')") %

                                   {'cfg_file': self._cfg_fname,

                                    'option': opt}, err.code)

                else:

                    raise

    def _set_db_connect(self):

        """check which module to use and set self._db_connect"""

        global _db_mod

        if self._cfg.dget('database.module').lower() == 'psycopg2':

            try:

                _db_mod = __import__('psycopg2')

            except ImportError:

                raise VMMError(_(u"Unable to import database module '%s'") %

                               'psycopg2', VMM_ERROR)

            self._db_connect = self._psycopg2_connect

        else:

            try:

                tmp = __import__('pyPgSQL', globals(), locals(), ['PgSQL'])

            except ImportError:

                raise VMMError(_(u"Unable to import database module '%s'") %

                               'pyPgSQL', VMM_ERROR)

            _db_mod = tmp.PgSQL

            self._db_connect = self._pypgsql_connect

    def _pypgsql_connect(self):

        """Creates a pyPgSQL.PgSQL.connection instance."""

        if self._dbh is None or (isinstance(self._dbh, _db_mod.Connection) and

                                  not self._dbh._isOpen):

            try:

                self._dbh = _db_mod.connect(

                        database=self._cfg.dget('database.name'),

                        user=self._cfg.pget('database.user'),

                        host=self._cfg.dget('database.host'),

                        port=self._cfg.dget('database.port'),

                        password=self._cfg.pget('database.pass'),

                        client_encoding='utf8', unicode_results=True)

                dbc = self._dbh.cursor()

                dbc.execute("SET NAMES 'UTF8'")

                dbc.close()

            except _db_mod.libpq.DatabaseError, err:

                raise VMMError(str(err), DATABASE_ERROR)

    def _psycopg2_connect(self):

        """Return a new psycopg2 connection object."""

        if self._dbh is None or \

          (isinstance(self._dbh, _db_mod.extensions.connection) and

           self._dbh.closed):

            try:

                self._dbh = _db_mod.connect(

                        host=self._cfg.dget('database.host'),

                        sslmode=self._cfg.dget('database.sslmode'),

                        port=self._cfg.dget('database.port'),

                        database=self._cfg.dget('database.name'),

                        user=self._cfg.pget('database.user'),

                        password=self._cfg.pget('database.pass'))

                self._dbh.set_client_encoding('utf8')

                _db_mod.extensions.register_type(_db_mod.extensions.UNICODE)

                dbc = self._dbh.cursor()

                dbc.execute("SET NAMES 'UTF8'")

                dbc.close()

            except _db_mod.DatabaseError, err:

                raise VMMError(str(err), DATABASE_ERROR)

    def _chk_other_address_types(self, address, exclude):

        """Checks if the EmailAddress *address* is known as `TYPE_ACCOUNT`,

        `TYPE_ALIAS` or `TYPE_RELOCATED`, but not as the `TYPE_*` specified

        by *exclude*.  If the *address* is known as one of the `TYPE_*`s

        the according `TYPE_*` constant will be returned.  Otherwise 0 will

        be returned."""

        assert exclude in (TYPE_ACCOUNT, TYPE_ALIAS, TYPE_RELOCATED) and \

                isinstance(address, EmailAddress)

        if exclude is not TYPE_ACCOUNT:

            account = Account(self._dbh, address)

            if account:

                return TYPE_ACCOUNT

        if exclude is not TYPE_ALIAS:

            alias = Alias(self._dbh, address)

            if alias:

                return TYPE_ALIAS

        if exclude is not TYPE_RELOCATED:

            relocated = Relocated(self._dbh, address)

            if relocated:

                return TYPE_RELOCATED

        return 0

    def _is_other_address(self, address, exclude):

        """Checks if *address* is known for an Account (TYPE_ACCOUNT),

        Alias (TYPE_ALIAS) or Relocated (TYPE_RELOCATED), except for

        *exclude*.  Returns `False` if the address is not known for other

        types.

        Raises a `VMMError` if the address is known.

        """

        other = self._chk_other_address_types(address, exclude)

        if not other:

            return False

        # TP: %(a_type)s will be one of: 'an account', 'an alias' or

        # 'a relocated user'

        msg = _(u"There is already %(a_type)s with the address '%(address)s'.")

        raise VMMError(msg % {'a_type': OTHER_TYPES[other][0],

                              'address': address}, OTHER_TYPES[other][1])

    def _get_account(self, address):

        """Return an Account instances for the given address (str)."""

        address = EmailAddress(address)

        self._db_connect()

        return Account(self._dbh, address)

    def _get_alias(self, address):

        """Return an Alias instances for the given address (str)."""

        address = EmailAddress(address)

        self._db_connect()

        return Alias(self._dbh, address)

    def _get_relocated(self, address):

        """Return a Relocated instances for the given address (str)."""

        address = EmailAddress(address)

        self._db_connect()

        return Relocated(self._dbh, address)

    def _get_domain(self, domainname):

        """Return a Domain instances for the given domain name (str)."""

        self._db_connect()

        return Domain(self._dbh, domainname)

    def _get_disk_usage(self, directory):

        """Estimate file space usage for the given directory.

        Arguments:

        `directory` : basestring

          The directory to summarize recursively disk usage for

        """

        if lisdir(directory):

            return Popen([self._cfg.dget('bin.du'), "-hs", directory],

                         stdout=PIPE).communicate()[0].split('\t')[0]

        else:

            self._warnings.append(_('No such directory: %s') % directory)

            return 0

    def _make_domain_dir(self, domain):

        """Create a directory for the `domain` and its accounts."""

        cwd = os.getcwd()

        hashdir, domdir = domain.directory.split(os.path.sep)[-2:]

        dir_created = False

        os.chdir(self._cfg.dget('misc.base_directory'))

        if not os.path.exists(hashdir):

            os.mkdir(hashdir, 0711)

            os.chown(hashdir, 0, 0)

            dir_created = True

        if not dir_created and not lisdir(hashdir):

            raise VMMError(_(u"'%s' is not a directory.") % hashdir,

                           NO_SUCH_DIRECTORY)

        if os.path.exists(domain.directory):

            raise VMMError(_(u"The file/directory '%s' already exists.") %

                           domain.directory, VMM_ERROR)

        os.mkdir(os.path.join(hashdir, domdir),

                 self._cfg.dget('domain.directory_mode'))

        os.chown(domain.directory, 0, domain.gid)

        os.chdir(cwd)

    def _make_home(self, account):

        """Create a home directory for the new Account *account*."""

        domdir = account.domain.directory

        if not lisdir(domdir):

            self._make_domain_dir(account.domain)

        os.umask(0007)

        uid = account.uid

        os.chdir(domdir)

        os.mkdir('%s' % uid, self._cfg.dget('account.directory_mode'))

        os.chown('%s' % uid, uid, account.gid)

    def _make_account_dirs(self, account):

        """Create all necessary directories for the account."""

        oldpwd = os.getcwd()

        self._make_home(account)

        mailbox = new_mailbox(account)

        mailbox.create()

        folders = self._cfg.dget('mailbox.folders').split(':')

        if any(folders):

            bad = mailbox.add_boxes(folders,

                                    self._cfg.dget('mailbox.subscribe'))

            if bad:

                self._warnings.append(_(u"Skipped mailbox folders:") +

                                      '\n\t- ' + '\n\t- '.join(bad))

        os.chdir(oldpwd)

    def _delete_home(self, domdir, uid, gid):

        """Delete a user's home directory.

        Arguments:

        `domdir` : basestring

          The directory of the domain the user belongs to

          (commonly AccountObj.domain.directory)

        `uid` : int/long

          The user's UID (commonly AccountObj.uid)

        `gid` : int/long

          The user's GID (commonly AccountObj.gid)

        """

        assert all(isinstance(xid, (long, int)) for xid in (uid, gid)) and \

                isinstance(domdir, basestring)

        if uid < MIN_UID or gid < MIN_GID:

            raise VMMError(_(u"UID '%(uid)u' and/or GID '%(gid)u' are less "

                             u"than %(min_uid)u/%(min_gid)u.") % {'uid': uid,

                           'gid': gid, 'min_gid': MIN_GID, 'min_uid': MIN_UID},

                           MAILDIR_PERM_MISMATCH)

        if domdir.count('..'):

            raise VMMError(_(u'Found ".." in domain directory path: %s') %

                           domdir, FOUND_DOTS_IN_PATH)

        if not lisdir(domdir):

            raise VMMError(_(u"No such directory: %s") % domdir,

                           NO_SUCH_DIRECTORY)

        os.chdir(domdir)

        userdir = '%s' % uid

        if not lisdir(userdir):

            self._warnings.append(_(u"No such directory: %s") %

                                  os.path.join(domdir, userdir))

            return

        mdstat = os.lstat(userdir)

        if (mdstat.st_uid, mdstat.st_gid) != (uid, gid):