"""cubicweb-ctl commands and command handlers specific to the server.serverconfig

:organization: Logilab

:copyright: 2001-2009 LOGILAB S.A. (Paris, FRANCE), license is LGPL v2.

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

:license: GNU Lesser General Public License, v2.1 - http://www.gnu.org/licenses

"""

__docformat__ = "restructuredtext en"

import sys

import os

from logilab.common.configuration import REQUIRED, Configuration

from logilab.common.clcommands import register_commands, cmd_run, pop_arg

from cubicweb import AuthenticationError, ExecutionError, ConfigurationError

from cubicweb.toolsutils import Command, CommandHandler, confirm

from cubicweb.server import SOURCE_TYPES

from cubicweb.server.utils import ask_source_config

from cubicweb.server.serverconfig import ServerConfiguration

# 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.common.db import get_connection

    dbhost = source['db-host']

    if dbname is None:

        dbname = source['db-name']

    driver = source['db-driver']

    print '**** connecting to %s database %s@%s' % (driver, dbname, dbhost),

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

        user = source['db-user']

        print 'as', user

        if source.get('db-password'):

            password = source['db-password']

        else:

            password = getpass('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('user (%r by default): ' % default_user)

        user = user or default_user

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

            password = source['db-password']

        else:

            password = getpass('password: ')

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

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

def system_source_cnx(source, dbms_system_base=False,

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

    """shortcut to get a connextion to the application 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 application database)

    """

    if dbms_system_base:

        from logilab.common.adbh import get_adv_func_helper

        system_db = get_adv_func_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)

def _db_sys_cnx(source, what, db=None, user=None, verbose=True):

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

    or a database

    """

    from logilab.common.adbh import get_adv_func_helper

    special_privs = ''

    driver = source['db-driver']

    helper = get_adv_func_helper(driver)

    if user is not None and helper.users_support:

        special_privs += '%s USER' % what

    if db is not None:

        special_privs += ' %s DATABASE' % what

    # connect on the dbms system base to create our base

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

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

        except AuthenticationError:

            print '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 application by copying files from the given cube and by

        asking information necessary to build required configuration files

        """

        config = self.config

        print 'application\'s repository configuration'

        print '-' * 72

        config.input_config('email', inputlevel)

        if config.pyro_enabled():

            config.input_config('pyro-server', inputlevel)

        print

        print 'repository sources configuration'

        print '-' * 72

        sourcesfile = config.sources_file()

        sconfig = Configuration(options=SOURCE_TYPES['native'].options)

        sconfig.adapter = 'native'

        sconfig.input_config(inputlevel=inputlevel)

        sourcescfg = {'system': sconfig}

        for cube in cubes:

            # if a source is named as the cube containing it, we need the

            # source to use the cube, so add it.

            if cube in SOURCE_TYPES:

                sourcescfg[cube] = ask_source_config(cube, inputlevel)

        while raw_input('enter another source [y/N]: ').strip().lower() == 'y':

            available = sorted(stype for stype in SOURCE_TYPES

                               if not stype in cubes)

            while True:

                sourcetype = raw_input('source type (%s): ' % ', '.join(available))

                if sourcetype in available:

                    break

                print 'unknown source type, use one of the available type'

            while True:

                sourceuri = raw_input('source uri: ').strip()

                    break

                print 'uri already used, choose another one'

            sourcescfg[sourceuri] = ask_source_config(sourcetype)

            sourcemodule = SOURCE_TYPES[sourcetype].module

            if not sourcemodule.startswith('cubicweb.'):

                # module names look like cubes.mycube.themodule

                sourcecube = SOURCE_TYPES[sourcetype].module.split('.', 2)[1]

                # if the source adapter is coming from an external component,

                # ensure it's specified in used cubes

                if not sourcecube in cubes:

                    cubes.append(sourcecube)

        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 confirm('do you want to create repository\'s system database?'):

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

            cmd_run('db-create', self.config.appid, '--verbose=%s' % verbosity)

        else:

            print 'nevermind, you can do it later using the db-create command'

USER_OPTIONS =  (

    ('login', {'type' : 'string',

               'default': REQUIRED,

               'help': "cubicweb manager account's login "

               '(this user will be created)',

               'inputlevel': 0,

               }),

    ('password', {'type' : 'password',

                  'help': "cubicweb manager account's password",

                  'inputlevel': 0,

                  }),

    )

class RepositoryDeleteHandler(CommandHandler):

    cmdname = 'delete'

    cfgname = 'repository'

    def cleanup(self):

        """remove application's configuration and database"""

        from logilab.common.adbh import get_adv_func_helper

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

        dbname = source['db-name']

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

        if confirm('delete database %s ?' % dbname):

            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 \

                       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_command(self, ctlconf, debug):

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

        if debug:

            command.append('--debug')

        command.append(self.config.appid)

        return ' '.join(command)

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

class CreateApplicationDBCommand(Command):

    """Create the system database of an application (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...).

    <application>

      the identifier of the application to initialize.

    """

    name = 'db-create'

    arguments = '<application>'

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

          }

         ),

        )

    def run(self, args):

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

        from logilab.common.adbh import get_adv_func_helper

        from indexer import get_indexer

        verbose = self.get('verbose')

        appid = pop_arg(args, msg="No application specified !")

        config = ServerConfiguration.config_for(appid)

        create_db = self.config.create_db

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

        driver = source['db-driver']

        helper = get_adv_func_helper(driver)

        if create_db:

            # connect on the dbms system base to create our base

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

            cursor = dbcnx.cursor()

            try:

                if helper.users_support:

                    user = source['db-user']

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

                           confirm('create db user %s ?' % user, default_is_yes=False):

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

                        print 'user %s created' % user

                dbname = source['db-name']

                if dbname in helper.list_databases(cursor):

                    if confirm('DB %s already exists -- do you want to drop it ?' % dbname):

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

                    else:

                        return

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

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

                                           source['db-encoding'])

                else:

                    helper.create_database(cursor, dbname,

                                           encoding=source['db-encoding'])

                dbcnx.commit()

                print 'database %s created' % source['db-name']

            except:

                dbcnx.rollback()

                raise

        cnx = system_source_cnx(source, special_privs='LANGUAGE C', verbose=verbose)

        cursor = cnx.cursor()

        indexer = get_indexer(driver)

        indexer.init_extensions(cursor)

        # postgres specific stuff

        if driver == 'postgres':

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

            for extlang in ('plpythonu', 'plpgsql'):

                helper.create_language(cursor, extlang)

        cursor.close()

        cnx.commit()

        print 'database for application %s created and necessary extensions installed' % appid

        print

        if confirm('do you want to initialize the system database?'):

            cmd_run('db-init', config.appid)

        else:

            print 'nevermind, you can do it later using the db-init command'

class InitApplicationCommand(Command):

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

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

    the system database.  The given user should have the create tables,

    and grant permissions.

    <application>

      the identifier of the application to initialize.

    """

    name = 'db-init'

    arguments = '<application>'

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

        from cubicweb.server import init_repository

        appid = pop_arg(args, msg="No application specified !")

        config = ServerConfiguration.config_for(appid)

        init_repository(config, drop=self.config.drop)

class GrantUserOnApplicationCommand(Command):

    """Grant a database user on a repository system database.

    <application>

      the identifier of the application

    <user>

      the database's user requiring grant access

    """

    name = 'db-grant-user'

    arguments = '<application> <user>'

    options = (

        ("set-owner",

         {'short': 'o', 'type' : "yn", 'metavar' : '<yes or no>',

          'default' : False,

          'help': 'Set the user as tables owner if yes (no by default).'}

         ),

        )

    def run(self, args):

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

        from cubicweb.server.sqlutils import sqlexec, sqlgrants

        appid = pop_arg(args, 1, msg="No application specified !")

        user = pop_arg(args, msg="No user specified !")

        config = ServerConfiguration.config_for(appid)

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

        set_owner = self.config.set_owner

        cnx = system_source_cnx(source, special_privs='GRANT')

        cursor = cnx.cursor()

        schema = config.load_schema()

        try:

            sqlexec(sqlgrants(schema, source['db-driver'], user,

                              set_owner=set_owner), cursor)

        except Exception, ex:

            cnx.rollback()

            import traceback

            traceback.print_exc()

            print 'An error occured:', ex

        else:

            cnx.commit()

            print 'grants given to %s on application %s' % (appid, user)