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

import logging

import subprocess

from logilab.common import nullobject

from logilab.common.shellutils import ASK, generate_password

from cubicweb import AuthenticationError, ExecutionError, ConfigurationError

from cubicweb.toolsutils import Command, CommandHandler, underline_title

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

    from logilab.database import get_connection, get_db_helper

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

                         **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:

        from logilab.database import get_db_helper

        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

    from logilab.database import get_db_helper

    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 db api connection it"""

    from cubicweb.dbapi import in_memory_repo_cnx

    from cubicweb.server.utils import manager_userpasswd

    try:

        login = config.sources()['admin']['login']

        pwd = config.sources()['admin']['password']

    except KeyError:

        login, pwd = manager_userpasswd()

    while True:

        try:

            return in_memory_repo_cnx(config, login, password=pwd)

        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)

            # ask for pyro configuration if pyro is activated and we're not

            # using a all-in-one config, in which case this is done by the web

            # side command handler

            if config.pyro_enabled() and config.name != 'all-in-one':

                config.input_config('pyro', 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)

ERROR = nullobject()

def confirm_on_error_or_die(msg, func, *args, **kwargs):

    try:

        return func(*args, **kwargs)

    except Exception as ex:

        print 'ERROR', ex

        if not ASK.confirm('An error occurred while %s. Continue anyway?' % msg):

            raise ExecutionError(str(ex))

    return ERROR

class RepositoryDeleteHandler(CommandHandler):

    cmdname = 'delete'

    cfgname = 'repository'

    def cleanup(self):

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

        from logilab.database import get_db_helper

        source = self.config.sources()['system']

        dbname = source['db-name']

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

        if ASK.confirm('Delete database %s ?' % dbname):

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

                if confirm_on_error_or_die(

                    'deleting database file %s' % dbname,

                    os.unlink, source['db-name']) is not ERROR:

                    print '-> database %s dropped.' % dbname

                return

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

            cnx = confirm_on_error_or_die('connecting to database %s' % dbname,

                                          _db_sys_cnx, source, 'DROP DATABASE')

            if cnx is ERROR:

                return

            cursor = cnx.cursor()

            try:

                if confirm_on_error_or_die(

                    'dropping database %s' % dbname,

                    cursor.execute, 'DROP DATABASE "%s"' % dbname) is not ERROR:

                    print '-> database %s dropped.' % dbname

                # XXX should check we are not connected as user

                if user and helper.users_support and \

                       ASK.confirm('Delete user %s ?' % user, default_is_yes=False):

                    if confirm_on_error_or_die(

                        'dropping user %s' % user,

                        cursor.execute, 'DROP USER %s' % user) is not ERROR:

                        print '-> user %s dropped.' % user

                cnx.commit()

            except BaseException:

                cnx.rollback()

                raise

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):

        """if pyro is enabled, ensure the repository is correctly unregistered

        """

        if self.config.pyro_enabled():

            from cubicweb.server.repository import pyro_unregister

            pyro_unregister(self.config)

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

        from logilab.database import get_db_helper

        check_options_consistency(self.config)

        automatic = self.get('automatic')

        appid = args.pop()

        config = ServerConfiguration.config_for(appid)

        source = config.sources()['system']

        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

            dbcnx = _db_sys_cnx(source, 'CREATE/DROP DATABASE and / or USER',

                                interactive=not automatic)

            cursor = dbcnx.cursor()

            try:

                if helper.users_support:

                    user = source['db-user']

                    if not helper.user_exists(cursor, user) and (automatic or \

                           ASK.confirm('Create db user %s ?' % user, default_is_yes=False)):

                        helper.create_user(source['db-user'], source.get('db-password'))

                        print '-> user %s created.' % user

                if dbname in helper.list_databases(cursor):

                    if automatic or ASK.confirm('Database %s already exists -- do you want to drop it ?' % dbname):

                        cursor.execute('DROP DATABASE "%s"' % dbname)

                    else:

                        print ('you may want to run "cubicweb-ctl db-init '

                               '--drop %s" manually to continue.' % config.appid)

                        return

                createdb(helper, source, dbcnx, cursor)

                dbcnx.commit()

                print '-> database %s created.' % dbname

            except BaseException:

                dbcnx.rollback()

                raise

        cnx = system_source_cnx(source, special_privs='CREATE LANGUAGE',

                                interactive=not automatic)

        cursor = cnx.cursor()

        helper.init_fti_extensions(cursor)

        cnx.commit()

        # postgres specific stuff

        if driver == 'postgres':

            # install plpythonu/plpgsql languages