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

"""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 logilab.common.configuration import Configuration

from logilab.common.shellutils import ASK

from cubicweb import AuthenticationError, ExecutionError, ConfigurationError

from cubicweb.toolsutils import Command, CommandHandler, underline_title

from cubicweb.cwctl import CWCTL

from cubicweb.server import SOURCE_TYPES

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, verbose=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 verbose:

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

        if dbhost:

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

        else:

            print dbname,

    if dbhelper.users_support:

            user = source['db-user']

            if verbose:

                print 'as', user

        else:

            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)

                password = source['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', verbose=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, verbose=verbose)

    return source_cnx(source, special_privs=special_privs, verbose=verbose)

    """

    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

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

    # CREATE DATABASE can't be executed in a transaction

    try:

        cnx.set_isolation_level(0)

    except AttributeError:

        # set_isolation_level() is psycopg specific

        pass

    return cnx

def repo_cnx(config):

    """return a in-memory repository and a db api connection it"""

    from cubicweb.dbapi import in_memory_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_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, 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

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

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

        # defs (in native.py)

        sconfig = SourceConfiguration(config,

                                      options=SOURCE_TYPES['native'].options)

        sconfig.input_config(inputlevel=inputlevel)

        sourcescfg = {'system': sconfig}

        print

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

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

            verbosity = (self.config.mode == 'installed') and 'y' or 'n'

            CWCTL.run(['db-create', self.config.appid, '--verbose=%s' % verbosity])

        else:

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

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

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

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

                return

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

            cnx = _db_sys_cnx(source, 'DROP DATABASE', user=user)

            cursor = cnx.cursor()

            try:

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

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

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

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

                cnx.commit()

            except:

                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 %s' % config['log-threshold'].lower())

        command.append(config.appid)

        os.system(' '.join(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 = (

        ('create-db',

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

          'default': True,

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

        ('verbose',

         {'short': 'v', 'type' : 'yn', 'metavar': '<verbose>',

          'default': 'n',

          'help': 'verbose mode: will ask all possible configuration questions',

          }

         ),

        ('automatic',

         {'short': 'a', 'type' : 'yn', 'metavar': '<auto>',

          'default': 'n',

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

          }

         ),

        )

    def run(self, args):

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

        from logilab.database import get_db_helper

        verbose = self.get('verbose')

        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

            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['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:

                        return

                createdb(helper, source, dbcnx, cursor)

                dbcnx.commit()

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

            except:

                dbcnx.rollback()

                raise

        cursor = cnx.cursor()

        helper.init_fti_extensions(cursor)

        # postgres specific stuff

        if driver == 'postgres':

            # install plpythonu/plpgsql language if not installed by the cube

            langs = sys.platform == 'win32' and ('plpgsql',) or ('plpythonu', 'plpgsql')

            for extlang in langs:

                helper.create_language(cursor, extlang)

        cursor.close()

        cnx.commit()

        print '-> database for instance %s created and necessary extensions installed.' % appid

        print

        if automatic or ASK.confirm('Run db-init to initialize the system database ?'):

            CWCTL.run(['db-init', config.appid])

        else:

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

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

class InitInstanceCommand(Command):

    """Initialize the system database of an instance (run after 'db-create').

    Notice this will be done using user specified in the sources files, so this

    user should have the create tables grant permissions on the database.

    <instance>

      the identifier of the instance to initialize.

    """

    name = 'db-init'

    arguments = '<instance>'

    min_args = max_args = 1

    options = (

        ('drop',

         {'short': 'd', 'action': 'store_true',

          'default': False,

          'help': 'insert drop statements to remove previously existant \

tables, indexes... (no by default)'}),

        )

    def run(self, args):

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

        from cubicweb.server import init_repository

        from logilab.database import get_connection

        appid = args[0]

        config = ServerConfiguration.config_for(appid)

        try:

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

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

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

            get_connection(

                system['db-driver'], database=system['db-name'],

                host=system.get('db-host'), port=system.get('db-port'),