# -*- coding: utf-8 -*-

# copyright 2003-2016 LOGILAB S.A. (Paris, FRANCE), all rights reserved.

# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr

#

# This file is part of CubicWeb.

#

# CubicWeb is free software: you can redistribute it and/or modify it under the

# terms of the GNU Lesser General Public License as published by the Free

# Software Foundation, either version 2.1 of the License, or (at your option)

# any later version.

#

# CubicWeb is distributed in the hope that it will be useful, but WITHOUT

# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

# FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more

# details.

#

# You should have received a copy of the GNU Lesser General Public License along

# with CubicWeb.  If not, see <http://www.gnu.org/licenses/>.

"""

.. _ResourceMode:

Resource mode

-------------

Standard resource mode

``````````````````````

A resource *mode* is a predefined set of settings for various resources

directories, such as cubes, instances, etc. to ease development with the

framework. There are two running modes with *CubicWeb*:

* **system**: resources are searched / created in the system directories (eg

  usually requiring root access):

  - instances are stored in :file:`<INSTALL_PREFIX>/etc/cubicweb.d`

  - temporary files (such as pid file) in :file:`<INSTALL_PREFIX>/var/run/cubicweb`

  where `<INSTALL_PREFIX>` is the detected installation prefix ('/usr/local' for

  instance).

* **user**: resources are searched / created in the user home directory:

  - instances are stored in :file:`~/etc/cubicweb.d`

  - temporary files (such as pid file) in :file:`/tmp`

.. _CubicwebWithinVirtualEnv:

Within virtual environment

``````````````````````````

When installed within a virtualenv, CubicWeb will look for instances data as in

user mode by default, that is in $HOME/etc/cubicweb.d. However the

CW_INSTANCES_DIR environment variable should be preferably used.

.. _virtualenv: http://pypi.python.org/pypi/virtualenv

Custom resource location

````````````````````````

Notice that each resource path may be explicitly set using an environment

variable if the default doesn't suit your needs. Here are the default resource

directories that are affected according to mode:

* **system**: ::

        CW_INSTANCES_DIR = <INSTALL_PREFIX>/etc/cubicweb.d/

        CW_INSTANCES_DATA_DIR = <INSTALL_PREFIX>/var/lib/cubicweb/instances/

        CW_RUNTIME_DIR = <INSTALL_PREFIX>/var/run/cubicweb/

* **user**: ::

        CW_INSTANCES_DIR = ~/etc/cubicweb.d/

        CW_INSTANCES_DATA_DIR = ~/etc/cubicweb.d/

        CW_RUNTIME_DIR = /tmp

Cubes search path is also affected, see the :ref:`Cube` section.

Setting Cubicweb Mode

`````````````````````

By default, the mode is set to 'system' for standard installation. The mode is

set to 'user' if `cubicweb is used from a mercurial repository`_. You can force

this by setting the :envvar:`CW_MODE` environment variable to either 'user' or

'system' so you can easily:

* use system wide installation but user specific instances and all, without root

  privileges on the system (`export CW_MODE=user`)

* use local checkout of cubicweb on system wide instances (requires root

  privileges on the system (`export CW_MODE=system`)

If you've a doubt about the mode you're currently running, check the first line

outputed by the :command:`cubicweb-ctl list` command.

.. _`cubicweb is used from a mercurial repository`: CubicwebDevelopmentMod_

.. _CubicwebDevelopmentMod:

Development Mode (source)

`````````````````````````

If :file:`.hg` directory is found into the cubicweb package, there are

specific resource rules.

`<CW_SOFTWARE_ROOT>` is the source checkout's ``cubicweb`` directory:

* cubicweb migration files are searched in `<CW_SOFTWARE_ROOT>/misc/migration`

  instead of `<INSTALL_PREFIX>/share/cubicweb/migration/`.

Development Mode (virtualenv)

`````````````````````````````

If a virtualenv is found to be activated (i.e. a VIRTUAL_ENV variable is found

in environment), the virtualenv root is used as `<INSTALL_PREFIX>`. This, in

particular, makes it possible to work in `setuptools development mode`_

(``python setup.py develop``) without any further configuration.

.. _`setuptools development mode`: https://pythonhosted.org/setuptools/setuptools.html#development-mode

.. _ConfigurationEnv:

Environment configuration

-------------------------

Python

``````

If you installed *CubicWeb* by cloning the Mercurial shell repository or from source

distribution, then you will need to update the environment variable PYTHONPATH by

adding the path to `cubicweb`:

Add the following lines to either :file:`.bashrc` or :file:`.bash_profile` to

configure your development environment ::

    export PYTHONPATH=/full/path/to/grshell-cubicweb

If you installed *CubicWeb* with packages, no configuration is required and your

new cubes will be placed in `/usr/share/cubicweb/cubes` and your instances will

be placed in `/etc/cubicweb.d`.

CubicWeb

````````

Here are all environment variables that may be used to configure *CubicWeb*:

.. envvar:: CW_MODE

   Resource mode: user or system, as explained in :ref:`ResourceMode`.

.. envvar:: CW_INSTANCES_DIR

   Directory where cubicweb instances will be found.

.. envvar:: CW_INSTANCES_DATA_DIR

   Directory where cubicweb instances data will be written (backup file...)

.. envvar:: CW_RUNTIME_DIR

   Directory where pid files will be written

"""

import importlib

import logging

import logging.config

import os

from os.path import (exists, join, expanduser, abspath,

                     basename, dirname, splitext, realpath)

import pkgutil

import pkg_resources

from smtplib import SMTP

import stat

import sys

from threading import Lock

from warnings import filterwarnings

from logilab.common.decorators import cached

from logilab.common.logging_ext import set_log_methods, init_log

from logilab.common.configuration import (Configuration, Method,

                                          ConfigurationMixIn, merge_options,

                                          _validate as lgc_validate)

from cubicweb import (CW_SOFTWARE_ROOT, CW_MIGRATION_MAP,

                      ConfigurationError, Binary, _)

from cubicweb.toolsutils import create_dir, option_value_from_env

CONFIGURATIONS = []

SMTP_LOCK = Lock()

def configuration_cls(name):

    """return the configuration class registered with the given name"""

    try:

        return [c for c in CONFIGURATIONS if c.name == name][0]

    except IndexError:

        raise ConfigurationError('no such config %r (check it exists with "cubicweb-ctl list")' % name)

def possible_configurations(directory):

    """return a list of installed configurations in a directory

    according to *-ctl files

    """

    return [name for name in ('repository', 'all-in-one', 'pyramid')

            if exists(join(directory, '%s.conf' % name))]

def guess_configuration(directory):

    """try to guess the configuration to use for a directory. If multiple

    configurations are found, ConfigurationError is raised

    """

    modes = possible_configurations(directory)

    if len(modes) != 1:

        raise ConfigurationError('unable to guess configuration from %r %s'

                                 % (directory, modes))

    return modes[0]

def _cube_pkgname(cube):

    if not cube.startswith('cubicweb_'):

        return 'cubicweb_' + cube

    return cube

def _expand_modname(modname, recursive=True):

    """expand modules names `modname` if exists by recursively walking

    submodules and subpackages and yield (submodname, filepath) including

    `modname` itself

    If the file ends with .pyc or .pyo (python bytecode) also check that the

    corresponding source .py file exists before yielding.

    If `recursive` is False skip subpackages.

    """

    try:

        loader = pkgutil.find_loader(modname)

    except ImportError:

        return

    if not loader:

        return

    def check_source_file(filepath):

        if filepath[-4:] in ('.pyc', '.pyo'):

            if not exists(filepath[:-1]):

                return False

        return True

    filepath = loader.get_filename()

    if not check_source_file(filepath):

        return

    yield modname, filepath

    if loader.is_package(modname):

        path = dirname(filepath)

        for subloader, subname, ispkg in pkgutil.walk_packages([path]):

            submodname = '.'.join([modname, subname])

            if not ispkg:

                filepath = subloader.find_module(subname).get_filename()

                if check_source_file(filepath):

                    yield submodname, filepath

            elif recursive:

                for x in _expand_modname(submodname, recursive=True):

                    yield x

# persistent options definition

PERSISTENT_OPTIONS = (

    ('encoding',

     {'type' : 'string',

      'default': 'UTF-8',

      'help': _('user interface encoding'),

      'group': 'ui', 'sitewide': True,

      }),

    ('language',

     {'type' : 'string',

      'default': 'en',

      'vocabulary': Method('available_languages'),

      'help': _('language of the user interface'),

      'group': 'ui',

      }),

    ('date-format',

     {'type' : 'string',

      'default': '%Y/%m/%d',

      'help': _('how to format date in the ui (see <a href="http://docs.python.org/library/datetime.html#strftime-strptime-behavior">this page</a> for format description)'),

      'group': 'ui',

      }),

    ('datetime-format',

     {'type' : 'string',

      'default': '%Y/%m/%d %H:%M',

      'help': _('how to format date and time in the ui (see <a href="http://docs.python.org/library/datetime.html#strftime-strptime-behavior">this page</a> for format description)'),

      'group': 'ui',

      }),

    ('time-format',

     {'type' : 'string',

      'default': '%H:%M',

      'help': _('how to format time in the ui (see <a href="http://docs.python.org/library/datetime.html#strftime-strptime-behavior">this page</a> for format description)'),

      'group': 'ui',

      }),

    ('float-format',

     {'type' : 'string',

      'default': '%.3f',

      'help': _('how to format float numbers in the ui'),

      'group': 'ui',

      }),

    ('default-text-format',

     {'type' : 'choice',

      'choices': ('text/plain', 'text/rest', 'text/html', 'text/markdown'),

      'default': 'text/plain',

      'help': _('default text format for rich text fields.'),

      'group': 'ui',

      }),

    ('short-line-size',

     {'type' : 'int',

      'default': 80,

      'help': _('maximum number of characters in short description'),

      'group': 'navigation',

      }),

    )

def register_persistent_options(options):

    global PERSISTENT_OPTIONS

    PERSISTENT_OPTIONS = merge_options(PERSISTENT_OPTIONS + options)

CFGTYPE2ETYPE_MAP = {

    'string': 'String',

    'choice': 'String',

    'yn':     'Boolean',

    'int':    'Int',

    'float' : 'Float',

    }

_INSTALL_PREFIX = os.environ.get('CW_INSTALL_PREFIX', sys.prefix)

_USR_INSTALL = _INSTALL_PREFIX == '/usr'

class CubicWebNoAppConfiguration(ConfigurationMixIn):

    """base class for cubicweb configuration without a specific instance directory

    """

    # to set in concrete configuration

    name = None

    # log messages format (see logging module documentation for available keys)

    log_format = '%(asctime)s - (%(name)s) %(levelname)s: %(message)s'

    # the format below can be useful to debug multi thread issues:

    # log_format = '%(asctime)s - [%(threadName)s] (%(name)s) %(levelname)s: %(message)s'

    # nor remove appobjects based on unused interface [???]

    cleanup_unused_appobjects = True

    quick_start = False

    if 'VIRTUAL_ENV' in os.environ:

        mode = os.environ.get('CW_MODE', 'user')

    else:

        mode = os.environ.get('CW_MODE', 'system')

    assert mode in ('system', 'user'), '"CW_MODE" should be either "user" or "system"'

    options = (

       ('log-threshold',

         {'type' : 'string', # XXX use a dedicated type?

          'default': 'WARNING',

          'help': 'server\'s log level',

          'group': 'main', 'level': 1,

          }),

        ('umask',

         {'type' : 'int',

          'default': 0o077,

          'help': 'permission umask for files created by the server',

          'group': 'main', 'level': 2,

          }),

        # common configuration options which are potentially required as soon as

        # you're using "base" application objects (ie to really server/web

        # specific)

        ('base-url',

         {'type' : 'string',

          'default': None,

          'help': 'web server root url',

          'group': 'main', 'level': 1,

          }),

        ('allow-email-login',

         {'type' : 'yn',

          'default': False,

          'help': 'allow users to login with their primary email if set',

          'group': 'main', 'level': 2,

          }),

        ('mangle-emails',

         {'type' : 'yn',

          'default': False,

          'help': "don't display actual email addresses but mangle them if \

this option is set to yes",

          'group': 'email', 'level': 3,

          }),

        )

    def __getitem__(self, key):

        """Get configuration option, by first looking at environmnent."""

        file_value = super(CubicWebNoAppConfiguration, self).__getitem__(key)

        value = option_value_from_env(key, file_value)

        if value is not None:

            option_def = self.get_option_def(key)

            value = lgc_validate(value, option_def)

        return value

    # static and class methods used to get instance independant resources ##

    @staticmethod

    def cubicweb_version():

        """return installed cubicweb version"""

        from logilab.common.changelog import Version

        str_base_version = pkg_resources.get_distribution('cubicweb').parsed_version.base_version

        version = tuple([int(x) for x in str_base_version.split('.')])

        assert len(version) == 3, version

        return Version(version)

    @staticmethod

    def persistent_options_configuration():

        return Configuration(options=PERSISTENT_OPTIONS)

    @classmethod