# copyright 2003-2014 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/>.

"""cubicweb-ctl commands and command handlers specific to the repository"""

__docformat__ = 'restructuredtext en'

# *ctl module should limit the number of import to be imported as quickly as

# possible (for cubicweb-ctl reactivity, necessary for instance for usable bash

# completion). So import locally in command helpers.

import sys

import os

from contextlib import contextmanager

import logging

import subprocess

from logilab.common import nullobject

from logilab.common.configuration import Configuration, merge_options

from logilab.common.shellutils import ASK, generate_password

from logilab.database import get_db_helper, get_connection

from cubicweb import AuthenticationError, ExecutionError, ConfigurationError

from cubicweb.toolsutils import Command, CommandHandler, underline_title

from cubicweb.cwctl import CWCTL, check_options_consistency, ConfigureInstanceCommand

from cubicweb.server import SOURCE_TYPES

from cubicweb.server.repository import Repository

from cubicweb.server.serverconfig import (

    USER_OPTIONS, ServerConfiguration, SourceConfiguration,

    ask_source_config, generate_source_config)

# utility functions ###########################################################

def source_cnx(source, dbname=None, special_privs=False, interactive=True):

    """open and return a connection to the system database defined in the

    given server.serverconfig

    """

    from getpass import getpass

    dbhost = source.get('db-host')

    if dbname is None:

        dbname = source['db-name']

    driver = source['db-driver']

    dbhelper = get_db_helper(driver)

    if interactive:

        print '-> connecting to %s database' % driver,

        if dbhost:

            print '%s@%s' % (dbname, dbhost),

        else:

            print dbname,

    if dbhelper.users_support:

        if not interactive or (not special_privs and source.get('db-user')):

            user = source.get('db-user', os.environ.get('USER', ''))

            if interactive:

                print 'as', user

            password = source.get('db-password')

        else:

            print

            if special_privs:

                print 'WARNING'

                print ('the user will need the following special access rights '

                       'on the database:')

                print special_privs

                print

            default_user = source.get('db-user', os.environ.get('USER', ''))

            user = raw_input('Connect as user ? [%r]: ' % default_user)

            user = user.strip() or default_user

            if user == source.get('db-user'):

                password = source.get('db-password')

            else:

                password = getpass('password: ')

    else:

        user = password = None

    extra_args = source.get('db-extra-arguments')

    extra = extra_args and {'extra_args': extra_args} or {}

    cnx = get_connection(driver, dbhost, dbname, user, password=password,

                         port=source.get('db-port'),

                         schema=source.get('db-namespace'),

                         **extra)

    try:

        cnx.logged_user = user

    except AttributeError:

        # C object, __slots__

        from logilab.database import _SimpleConnectionWrapper

        cnx = _SimpleConnectionWrapper(cnx)

        cnx.logged_user = user

    return cnx

def system_source_cnx(source, dbms_system_base=False,

                      special_privs='CREATE/DROP DATABASE', interactive=True):

    """shortcut to get a connextion to the instance system database

    defined in the given config. If <dbms_system_base> is True,

    connect to the dbms system database instead (for task such as

    create/drop the instance database)

    """

    if dbms_system_base:

        system_db = get_db_helper(source['db-driver']).system_database()

        return source_cnx(source, system_db, special_privs=special_privs,

                          interactive=interactive)

    return source_cnx(source, special_privs=special_privs,

                      interactive=interactive)

def _db_sys_cnx(source, special_privs, interactive=True):

    """return a connection on the RDMS system table (to create/drop a user or a

    database)

    """

    import logilab.common as lgp

    lgp.USE_MX_DATETIME = False

    driver = source['db-driver']

    helper = get_db_helper(driver)

    # connect on the dbms system base to create our base

    cnx = system_source_cnx(source, True, special_privs=special_privs,

                            interactive=interactive)

    # disable autocommit (isolation_level(1)) because DROP and

    # CREATE DATABASE can't be executed in a transaction

    set_isolation_level = getattr(cnx, 'set_isolation_level', None)

    if set_isolation_level is not None:

        # set_isolation_level() is psycopg specific

        set_isolation_level(0)

    return cnx

def repo_cnx(config):

    """return a in-memory repository and a repoapi connection to it"""

    from cubicweb import repoapi

    from cubicweb.server.utils import manager_userpasswd

    try:

        login = config.default_admin_config['login']

        pwd = config.default_admin_config['password']

    except KeyError:

        login, pwd = manager_userpasswd()

    while True:

        try:

            repo = repoapi.get_repository(config=config)

            cnx = repoapi.connect(repo, login, password=pwd)

            return repo, cnx

        except AuthenticationError:

            print '-> Error: wrong user/password.'

            # reset cubes else we'll have an assertion error on next retry

            config._cubes = None

        login, pwd = manager_userpasswd()

# repository specific command handlers ########################################

class RepositoryCreateHandler(CommandHandler):

    cmdname = 'create'

    cfgname = 'repository'

    def bootstrap(self, cubes, automatic=False, inputlevel=0):

        """create an instance by copying files from the given cube and by asking

        information necessary to build required configuration files

        """

        config = self.config

        if not automatic:

            print underline_title('Configuring the repository')

            config.input_config('email', inputlevel)

            print '\n'+underline_title('Configuring the sources')

        sourcesfile = config.sources_file()

        # hack to make Method('default_instance_id') usable in db option defs

        # (in native.py)

        sconfig = SourceConfiguration(config,

                                      options=SOURCE_TYPES['native'].options)

        if not automatic:

            sconfig.input_config(inputlevel=inputlevel)

            print

        sourcescfg = {'system': sconfig}

        if automatic:

            # XXX modify a copy

            password = generate_password()

            print '-> set administrator account to admin / %s' % password

            USER_OPTIONS[1][1]['default'] = password

            sconfig = Configuration(options=USER_OPTIONS)

        else:

            sconfig = Configuration(options=USER_OPTIONS)

            sconfig.input_config(inputlevel=inputlevel)

        sourcescfg['admin'] = sconfig

        config.write_sources_file(sourcescfg)

        # remember selected cubes for later initialization of the database

        config.write_bootstrap_cubes_file(cubes)

    def postcreate(self, automatic=False, inputlevel=0):

        if automatic:

            CWCTL.run(['db-create', '--automatic', self.config.appid])

        elif ASK.confirm('Run db-create to create the system database ?'):

            CWCTL.run(['db-create', '--config-level', str(inputlevel),

                       self.config.appid])

        else:

            print ('-> nevermind, you can do it later with '

                   '"cubicweb-ctl db-create %s".' % self.config.appid)

@contextmanager

def db_transaction(source, privilege):

    """Open a transaction to the instance database"""

    cnx = system_source_cnx(source, special_privs=privilege)

    cursor = cnx.cursor()

    try:

        yield cursor

    except:

        cnx.rollback()

        cnx.close()

        raise

    else:

        cnx.commit()

        cnx.close()

@contextmanager

def db_sys_transaction(source, privilege):

    """Open a transaction to the system database"""

    cnx = _db_sys_cnx(source, privilege)

    cursor = cnx.cursor()

    try:

        yield cursor

    except:

        cnx.rollback()

        cnx.close()

        raise

    else:

        cnx.commit()

        cnx.close()

class RepositoryDeleteHandler(CommandHandler):

    cmdname = 'delete'

    cfgname = 'repository'

    def _drop_namespace(self, source):

        db_namespace = source.get('db-namespace')

        with db_transaction(source, privilege='DROP SCHEMA') as cursor:

            helper = get_db_helper(source['db-driver'])

            helper.drop_schema(cursor, db_namespace)

            print '-> database schema %s dropped' % db_namespace

    def _drop_database(self, source):

        dbname = source['db-name']

        if source['db-driver'] == 'sqlite':

            print 'deleting database file %(db-name)s' % source

            os.unlink(source['db-name'])

            print '-> database %(db-name)s dropped.' % source

        else:

            helper = get_db_helper(source['db-driver'])

            with db_sys_transaction(source, privilege='DROP DATABASE') as cursor:

                print 'dropping database %(db-name)s' % source

                cursor.execute('DROP DATABASE "%(db-name)s"' % source)

                print '-> database %(db-name)s dropped.' % source

    def _drop_user(self, source):

        user = source['db-user'] or None

        if user is not None:

            with db_sys_transaction(source, privilege='DROP USER') as cursor:

                print 'dropping user %s' % user

                cursor.execute('DROP USER %s' % user)

    def _cleanup_steps(self, source):

        # 1/ delete namespace if used

        db_namespace = source.get('db-namespace')

        if db_namespace:

            yield ('Delete database namespace "%s"' % db_namespace,

                   self._drop_namespace, True)

        # 2/ delete database

        yield ('Delete database "%(db-name)s"' % source,

               self._drop_database, True)

        # 3/ delete user

        helper = get_db_helper(source['db-driver'])

        if source['db-user'] and helper.users_support:

            # XXX should check we are not connected as user

            yield ('Delete user "%(db-user)s"' % source,

                   self._drop_user, False)

    def cleanup(self):

        """remove instance's configuration and database"""

        source = self.config.system_source_config

        for msg, step, default in self._cleanup_steps(source):

            if ASK.confirm(msg, default_is_yes=default):

                try:

                    step(source)

                except Exception as exc:

                    print 'ERROR', exc

                    if ASK.confirm('An error occurred. Continue anyway?',

                                   default_is_yes=False):

                        continue

                    raise ExecutionError(str(exc))

class RepositoryStartHandler(CommandHandler):

    cmdname = 'start'

    cfgname = 'repository'

    def start_server(self, config):

        command = ['cubicweb-ctl', 'start-repository']

        if config.debugmode:

            command.append('--debug')

        command.append('--loglevel')

        command.append(config['log-threshold'].lower())

        command.append(config.appid)

        subprocess.call(command)

        return 1

class RepositoryStopHandler(CommandHandler):

    cmdname = 'stop'

    cfgname = 'repository'

    def poststop(self):

# repository specific commands ################################################

def createdb(helper, source, dbcnx, cursor, **kwargs):

    if dbcnx.logged_user != source['db-user']:

        helper.create_database(cursor, source['db-name'], source['db-user'],

                               source['db-encoding'], **kwargs)

    else:

        helper.create_database(cursor, source['db-name'],

                               dbencoding=source['db-encoding'], **kwargs)

class CreateInstanceDBCommand(Command):

    """Create the system database of an instance (run after 'create').

    You will be prompted for a login / password to use to connect to

    the system database.  The given user should have almost all rights

    on the database (ie a super user on the DBMS allowed to create

    database, users, languages...).

    <instance>

      the identifier of the instance to initialize.

    """

    name = 'db-create'

    arguments = '<instance>'

    min_args = max_args = 1

    options = (

        ('automatic',

         {'short': 'a', 'action' : 'store_true',

          'default': False,

          'help': 'automatic mode: never ask and use default answer to every '

          'question. this may require that your login match a database super '

          'user (allowed to create database & all).',

          }),

        ('config-level',

         {'short': 'l', 'type' : 'int', 'metavar': '<level>',

          'default': 0,

          'help': 'configuration level (0..2): 0 will ask for essential '

          'configuration parameters only while 2 will ask for all parameters',

          }),

        ('create-db',

         {'short': 'c', 'type': 'yn', 'metavar': '<y or n>',

          'default': True,

          'help': 'create the database (yes by default)'

          }),

        )

    def run(self, args):

        """run the command with its specific arguments"""

        check_options_consistency(self.config)

        automatic = self.get('automatic')

        appid = args.pop()

        config = ServerConfiguration.config_for(appid)

        source = config.system_source_config

        dbname = source['db-name']

        driver = source['db-driver']

        helper = get_db_helper(driver)

        if driver == 'sqlite':

            if os.path.exists(dbname) and (

                automatic or

                ASK.confirm('Database %s already exists. Drop it?' % dbname)):

                os.unlink(dbname)

        elif self.config.create_db:

            print '\n'+underline_title('Creating the system database')

            # connect on the dbms system base to create our base