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

:organization: Logilab

:copyright: 2001-2008 LOGILAB S.A. (Paris, FRANCE), all rights reserved.

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

"""

__docformat__ = "restructuredtext en"

import os

from logilab.common.configuration import REQUIRED, Configuration, ini_format_section

from cubicweb import AuthenticationError, ExecutionError, ConfigurationError

from cubicweb.toolsutils import Command, CommandHandler, pop_arg, cmd_run, \

     register_commands, confirm, restrict_perms_to_user

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 generate_sources_file(sourcesfile, sourcescfg, keys=None):

    """serialize repository'sources configuration into a INI like file

    the `keys` parameter may be used to sort sections

    """

    from cubicweb.server.sources import SOURCE_TYPES

    if keys is None:

        keys = sourcescfg.keys()

    else:

        for key in sourcescfg:

            if not key in keys:

                keys.append(key)

    stream = open(sourcesfile, 'w')

    for uri in keys:

        sconfig = sourcescfg[uri]

        if isinstance(sconfig, dict):

            # get a Configuration object

            _sconfig = Configuration(options=SOURCE_TYPES[sconfig['adapter']].options)

            for attr, val in sconfig.items():

                if attr == 'uri': 

                    continue

                if attr == 'adapter':

                    _sconfig.adapter = val

                else:

                    _sconfig.set_option(attr, val)

            sconfig = _sconfig

        optsbysect = list(sconfig.options_by_section())

        assert len(optsbysect) == 1

        ini_format_section(stream, uri, optsbysect[0][1])

        if hasattr(sconfig, 'adapter'):

            print >> stream

            print >> stream, '# adapter for this source (YOU SHOULD NOT CHANGE THIS)'

            print >> stream, 'adapter=%s' % sconfig.adapter

        print >> stream

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'

        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

        """

        from cubicweb.server.sources import SOURCE_TYPES

        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}

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

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

            sconfig = Configuration(options=SOURCE_TYPES[sourcetype].options)

            sconfig.adapter = sourcetype

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

            assert not sourceuri in sourcescfg

            sconfig.input_config(inputlevel=inputlevel)

            sourcescfg[sourceuri] = sconfig

            # 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 sourcecube != 'cubicweb' and not sourcecube in cubes:

                cubes.append(sourcecube)

        sconfig = Configuration(options=USER_OPTIONS)

        sconfig.input_config(inputlevel=inputlevel)

        sourcescfg['admin'] = sconfig

        generate_sources_file(sourcesfile, sourcescfg, ['admin', 'system'])

        restrict_perms_to_user(sourcesfile)

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