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

# Copyright (c) 2007 - 2010, 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 pyPgSQL import PgSQL  # python-pgsql - http://pypgsql.sourceforge.net

from VirtualMailManager.Account import Account

from VirtualMailManager.Alias import Alias

from VirtualMailManager.AliasDomain import AliasDomain

from VirtualMailManager.common import exec_ok

from VirtualMailManager.Config import Config as Cfg

from VirtualMailManager.Domain import Domain, get_gid

from VirtualMailManager.EmailAddress import EmailAddress

from VirtualMailManager.errors import \

     DomainError, NotRootError, PermissionError, VMMError

from VirtualMailManager.mailbox import new as new_mailbox

from VirtualMailManager.pycompat import any

from VirtualMailManager.Relocated import Relocated

from VirtualMailManager.Transport import Transport

_ = lambda msg: msg

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

TYPE_ACCOUNT = 0x1

TYPE_ALIAS = 0x2

TYPE_RELOCATED = 0x4

OTHER_TYPES = {

}

class Handler(object):

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

    VirtualMailManager"""

    __slots__ = ('_Cfg', '_cfgFileName', '_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._cfgFileName = ''

        self.__warnings = []

        self._Cfg = None

        self._dbh = None

        if os.geteuid():

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

        if self.__chkCfgFile():

            self._Cfg = Cfg(self._cfgFileName)

            self._Cfg.load()

        if not skip_some_checks:

            self._Cfg.check()

            self._chkenv()

    def __findCfgFile(self):

        for path in ['/root', '/usr/local/etc', '/etc']:

            tmp = os.path.join(path, 'vmm.cfg')

            if os.path.isfile(tmp):

                self._cfgFileName = tmp

                break

        if not len(self._cfgFileName):

            raise VMMError(_(u"No 'vmm.cfg' found in: "

    def __chkCfgFile(self):

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

        self.__findCfgFile()

        fstat = os.stat(self._cfgFileName)

        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._cfgFileName,

        else:

            return True

    def _chkenv(self):

        """"""

        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)

        elif not os.path.isdir(basedir):

            raise VMMError(_(u"'%s' is not a directory.\n(vmm.cfg: section "

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

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

            try:

                exec_ok(val)

            except VMMError, err:

                    raise VMMError(_(u"'%(binary)s' doesn't exist.\n(vmm.cfg: "

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

                                   {'binary': val, 'option': opt}, err.code)

                    raise VMMError(_(u"'%(binary)s' is not executable.\n"

                                     u"(vmm.cfg: section 'bin', option "

                                     u"'%(option)s')") % {'binary': val,

                                   'option': opt}, err.code)

                else:

                    raise

    def __dbConnect(self):

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

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

                                  not self._dbh._isOpen):

            try:

                self._dbh = PgSQL.connect(

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

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

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

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

                        client_encoding='utf8', unicode_results=True)

                dbc = self._dbh.cursor()

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

                dbc.close()

            except PgSQL.libpq.DatabaseError, e:

    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

        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 __getAccount(self, address):

        address = EmailAddress(address)

        self.__dbConnect()

        return Account(self._dbh, address)

    def __getAlias(self, address):

        address = EmailAddress(address)

        self.__dbConnect()

        return Alias(self._dbh, address)

    def __getRelocated(self, address):

        address = EmailAddress(address)

        self.__dbConnect()

        return Relocated(self._dbh, address)

    def __getDomain(self, domainname):

        self.__dbConnect()

        return Domain(self._dbh, domainname)

    def __getDiskUsage(self, directory):

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

        Keyword arguments:

        directory -- the directory to summarize recursively disk usage for

        """

        if self.__isdir(directory):

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

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

        else:

            return 0

    def __isdir(self, directory):

        isdir = os.path.isdir(directory)

        if not isdir:

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

        return isdir

    def __make_domain_dir(self, domain):

        cwd = os.getcwd()

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

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

        if not os.path.isdir(hashdir):

            os.mkdir(hashdir, 0711)

            os.chown(hashdir, 0, 0)

        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*."""

        os.umask(0007)

        os.chdir(account.domain_directory)

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

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

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

        if uid > 0 and gid > 0:

            userdir = '%s' % uid

            if userdir.count('..') or domdir.count('..'):

                raise VMMError(_(u'Found ".." in home directory path.'),

            if os.path.isdir(domdir):

                os.chdir(domdir)

                if os.path.isdir(userdir):

                    mdstat = os.stat(userdir)

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

                    rmtree(userdir, ignore_errors=True)

                else:

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

    def __domDirDelete(self, domdir, gid):

        if gid > 0:

            if not self.__isdir(domdir):

                return

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

            domdirdirs = domdir.replace(basedir + '/', '').split('/')

            domdirparent = os.path.join(basedir, domdirdirs[0])

            if basedir.count('..') or domdir.count('..'):

                raise VMMError(_(u'Found ".." in domain directory path.'),

            if os.path.isdir(domdirparent):

                os.chdir(domdirparent)

                if os.lstat(domdirdirs[1]).st_gid != gid:

                rmtree(domdirdirs[1], ignore_errors=True)

    def hasWarnings(self):

        """Checks if warnings are present, returns bool."""

        return bool(len(self.__warnings))

    def getWarnings(self):

        """Returns a list with all available warnings and resets all

        warnings.

        """

        ret_val = self.__warnings[:]

        del self.__warnings[:]

        return ret_val

    def cfg_dget(self, option):

        """Get the configured value of the *option* (section.option).

        When the option was not configured its default value will be

        returned."""

        return self._Cfg.dget(option)

    def cfg_pget(self, option):

        """Get the configured value of the *option* (section.option)."""

        return self._Cfg.pget(option)

    def cfg_install(self):

        """Installs the cfg_dget method as ``cfg_dget`` into the built-in

        namespace."""

        import __builtin__

        assert 'cfg_dget' not in __builtin__.__dict__

        __builtin__.__dict__['cfg_dget'] = self._Cfg.dget

    def domainAdd(self, domainname, transport=None):

        dom = self.__getDomain(domainname)

        if transport is None:

            dom.set_transport(Transport(self._dbh,

                              transport=self._Cfg.dget('misc.transport')))

        else:

            dom.set_transport(Transport(self._dbh, transport=transport))

        dom.set_directory(self._Cfg.dget('misc.base_directory'))

        dom.save()

        self.__make_domain_dir(dom)

    def domainTransport(self, domainname, transport, force=None):

        if force is not None and force != 'force':

        dom = self.__getDomain(domainname)

        trsp = Transport(self._dbh, transport=transport)

        if force is None:

            dom.update_transport(trsp)

        else:

            dom.update_transport(trsp, force=True)

    def domainDelete(self, domainname, force=None):

        if force and force not in ('deluser', 'delalias', 'delall'):

            raise DomainError(_(u"Invalid argument: '%s'") % force,

        dom = self.__getDomain(domainname)

        gid = dom.gid

        domdir = dom.directory

        if self._Cfg.dget('domain.force_deletion') or force == 'delall':

            dom.delete(True, True)

        elif force == 'deluser':

            dom.delete(deluser=True)

        elif force == 'delalias':

            dom.delete(delalias=True)

        else:

            dom.delete()

        if self._Cfg.dget('domain.delete_directory'):

            self.__domDirDelete(domdir, gid)

    def domainInfo(self, domainname, details=None):

        if details not in [None, 'accounts', 'aliasdomains', 'aliases', 'full',

                           'relocated']:

            raise VMMError(_(u'Invalid argument: “%s”') % details,

        dom = self.__getDomain(domainname)