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

# copyright 2003-2010 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

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

A resource *mode* is a predifined 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*:

* '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`

* '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:`/var/run/cubicweb`

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

  instance).

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 = /var/lib/cubicweb/instances/

        CW_RUNTIME_DIR = /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.

By default, the mode automatically set to 'user' if a :file:`.hg` directory is found

in the cubicweb package, else it's set to 'system'. 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.

Also, if cubicweb is a mercurial checkout located in `<CW_SOFTWARE_ROOT>`:

* main cubes directory is `<CW_SOFTWARE_ROOT>/../cubes`. You can specify

  another one with :envvar:`CW_INSTANCES_DIR` environment variable or simply

  add some other directories by using :envvar:`CW_CUBES_PATH`

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

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

.. _ConfigurationEnv:

Environment configuration

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

Python

``````

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

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

adding the path to the forest `cubicweb`:

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

configure your development environment ::

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

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_CUBES_PATH

   Augments the default search path for cubes. You may specify several

   directories using ':' as separator (';' under windows environment).

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

"""

__docformat__ = "restructuredtext en"

_ = unicode

import sys

import os

import logging

from smtplib import SMTP

from threading import Lock

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

                     basename, isdir, dirname)

from warnings import warn

from logilab.common.decorators import cached, classproperty

from logilab.common.deprecation import deprecated

from logilab.common.logging_ext import set_log_methods, init_log

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

                                          ConfigurationMixIn, merge_options)

from cubicweb import (CW_SOFTWARE_ROOT, CW_MIGRATION_MAP,

                      ConfigurationError, Binary)

from cubicweb.toolsutils import env_path, create_dir

CONFIGURATIONS = []

SMTP_LOCK = Lock()

class metaconfiguration(type):

    """metaclass to automaticaly register configuration"""

    def __new__(mcs, name, bases, classdict):

        cls = super(metaconfiguration, mcs).__new__(mcs, name, bases, classdict)

        if classdict.get('name'):

            CONFIGURATIONS.append(cls)

        return cls

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', 'twisted', 'all-in-one')

            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 _find_prefix(start_path=CW_SOFTWARE_ROOT):

    """Runs along the parent directories of *start_path* (default to cubicweb source directory)

    looking for one containing a 'share/cubicweb' directory.

    The first matching directory is assumed as the prefix installation of cubicweb

    Returns the matching prefix or None.

    """

    prefix = start_path

    old_prefix = None

    if not isdir(start_path):

        prefix = dirname(start_path)

    while not isdir(join(prefix, 'share', 'cubicweb')) and prefix != old_prefix:

        old_prefix = prefix

        prefix = dirname(prefix)

    if isdir(join(prefix, 'share', 'cubicweb')):

        return prefix

    return sys.prefix

# 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 ("man strftime" 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 ("man strftime" for format description)'),

      'group': 'ui',

      }),

    ('time-format',

     {'type' : 'string',

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

      'help': _('how to format time in the ui ("man strftime" 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'),

      'default': 'text/html', # use fckeditor in the web ui

      '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',

    }

_forced_mode = os.environ.get('CW_MODE')

assert _forced_mode in (None, 'system', 'user')

CWDEV = exists(join(CW_SOFTWARE_ROOT, '.hg'))

try:

    _INSTALL_PREFIX = os.environ['CW_INSTALL_PREFIX']

except KeyError:

    _INSTALL_PREFIX = _find_prefix()

class CubicWebNoAppConfiguration(ConfigurationMixIn):

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

    """

    __metaclass__ = metaconfiguration

    # 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_interface_sobjects = True

    # debug mode

    debugmode = False

    if (CWDEV and _forced_mode != 'system'):

        mode = 'user'

        _CUBES_DIR = join(CW_SOFTWARE_ROOT, '../cubes')

    else:

        mode = _forced_mode or 'system'

        _CUBES_DIR = join(_INSTALL_PREFIX, 'share', 'cubicweb', 'cubes')

    CUBES_DIR = env_path('CW_CUBES_DIR', _CUBES_DIR, 'cubes', checkexists=False)

    CUBES_PATH = os.environ.get('CW_CUBES_PATH', '').split(os.pathsep)

    options = (

       ('log-threshold',

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

          'default': 'WARNING',

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

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

          }),

        # pyro options

        ('pyro-instance-id',

         {'type' : 'string',

          'default': Method('default_instance_id'),

          'help': 'identifier of the CubicWeb instance in the Pyro name server',

          'group': 'pyro', 'level': 1,

          }),

        ('pyro-ns-host',

         {'type' : 'string',

          'default': '',

          'help': 'Pyro name server\'s host. If not set, will be detected by a \

broadcast query. It may contains port information using <host>:<port> notation.',

          'group': 'pyro', 'level': 1,

          }),

        ('pyro-ns-group',

         {'type' : 'string',

          'default': 'cubicweb',

          'help': 'Pyro name server\'s group where the repository will be \

registered.',

          'group': 'pyro', 'level': 1,

          }),

        # 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,

          }),

        ('use-request-subdomain',

         {'type' : 'yn',

          'default': None,

          'help': ('if set, base-url subdomain is replaced by the request\'s '

                   'host, to help managing sites with several subdomains in a '

                   'single cubicweb instance'),

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

          }),

        ('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,

          }),

        )

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

    @staticmethod

    def cubicweb_version():

        """return installed cubicweb version"""

        from logilab.common.changelog import Version

        from cubicweb import __pkginfo__

        version = __pkginfo__.numversion

        assert len(version) == 3, version

        return Version(version)

    @staticmethod

    def persistent_options_configuration():

        return Configuration(options=PERSISTENT_OPTIONS)

    @classmethod

    def shared_dir(cls):

        """return the shared data directory (i.e. directory where standard

        library views and data may be found)

        """

        if CWDEV:

            return join(CW_SOFTWARE_ROOT, 'web')

        return cls.cube_dir('shared')

    @classmethod

    def i18n_lib_dir(cls):

        """return instance's i18n directory"""

        if CWDEV:

            return join(CW_SOFTWARE_ROOT, 'i18n')

        return join(cls.shared_dir(), 'i18n')

    @classmethod

    def available_cubes(cls):

        import re

        cubes = set()

        for directory in cls.cubes_search_path():

            if not exists(directory):

                cls.error('unexistant directory in cubes search path: %s'

                          % directory)

                continue

            for cube in os.listdir(directory):

                if cube == 'shared':

                    continue

                if not re.match('[_A-Za-z][_A-Za-z0-9]*$', cube):

                    continue # skip invalid python package name

                cubedir = join(directory, cube)

                if isdir(cubedir) and exists(join(cubedir, '__init__.py')):

                    cubes.add(cube)

        return sorted(cubes)