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

"""the cubicweb-ctl tool, based on logilab.common.clcommands to

provide a pluggable commands system.

"""

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

from warnings import filterwarnings

from os import listdir

from os.path import exists, join, isdir

try:

    from os import kill, getpgid

except ImportError:

    def kill(*args):

        """win32 kill implementation"""

    def getpgid():

        """win32 getpgid implementation"""

from logilab.common.clcommands import CommandLine

from logilab.common.shellutils import ASK

from logilab.common.configuration import merge_options

from logilab.common.decorators import clear_cache

from cubicweb import ConfigurationError, ExecutionError, BadCommandUsage

from cubicweb.cwconfig import CubicWebConfiguration as cwcfg, CONFIGURATIONS

from cubicweb.toolsutils import Command, rm, create_dir, underline_title

from cubicweb.__pkginfo__ import version as cw_version

# don't check duplicated commands, it occurs when reloading site_cubicweb

CWCTL = CommandLine('cubicweb-ctl', 'The CubicWeb swiss-knife.',

                    version=cw_version, check_duplicated_command=False)

def wait_process_end(pid, maxtry=10, waittime=1):

    """wait for a process to actually die"""

    import signal

    from time import sleep

    nbtry = 0

    while nbtry < maxtry:

        try:

            kill(pid, signal.SIGUSR1)

        except (OSError, AttributeError):  # XXX win32

            break

        nbtry += 1

        sleep(waittime)

    else:

        raise ExecutionError('can\'t kill process %s' % pid)

def list_instances(regdir):

    if isdir(regdir):

        return sorted(idir for idir in listdir(regdir) if isdir(join(regdir, idir)))

    else:

        return []

def detect_available_modes(templdir):

    modes = []

    for fname in ('schema', 'schema.py'):

        if exists(join(templdir, fname)):

            modes.append('repository')

            break

    for fname in ('data', 'views', 'views.py'):

        if exists(join(templdir, fname)):

            modes.append('web ui')

            break

    return modes

def available_cube_names(cwcfg):

    """Return a list of available cube names, with 'cubicweb_' prefix dropped.

    """

    def drop_prefix(cube):

        prefix = 'cubicweb_'

        if cube.startswith(prefix):

            cube = cube[len(prefix):]

        return cube

    return [drop_prefix(cube) for cube in cwcfg.available_cubes()]

def get_pdb():

    try:

        import ipdb

    except ImportError:

        import pdb

        return pdb

    else:

        return ipdb

class InstanceCommand(Command):

    """base class for command taking one instance id as arguments"""

    arguments = '<instance>'

    # enforce having one instance

    min_args = max_args = 1

    options = (

        ("force",

         {'short': 'f', 'action': 'store_true',

          'default': False,

          'help': 'force command without asking confirmation',

          }

         ),

        ("pdb",

         {'action': 'store_true', 'default': False,

          'help': 'launch pdb on exception',

          }

         ),

    )

    actionverb = None

    def run(self, args):

        """run the <command>_method on each argument (a list of instance

        identifiers)

        """

        appid = args[0]

        cmdmeth = getattr(self, '%s_instance' % self.name)

        try:

            status = cmdmeth(appid) or 0

        except (ExecutionError, ConfigurationError) as ex:

            sys.stderr.write('instance %s not %s: %s\n' % (

                appid, self.actionverb, ex))

            status = 4

        except Exception as ex:

            import traceback

            traceback.print_exc()

            sys.stderr.write('instance %s not %s: %s\n' % (

                appid, self.actionverb, ex))

            status = 8

            sys.stderr.write('%s aborted\n' % self.name)

        if status != 0 and self.config.pdb:

            exception_type, exception, traceback_ = sys.exc_info()

            pdb = get_pdb()

            pdb.post_mortem(traceback_)

        sys.exit(status)

# base commands ###############################################################

class ListCommand(Command):

    """List configurations, cubes and instances.

    List available configurations, installed cubes, and registered instances.

    If given, the optional argument allows to restrict listing only a category of items.

    """

    name = 'list'

    arguments = '[all|cubes|configurations|instances]'

    options = (

        ('verbose',

         {'short': 'v', 'action': 'store_true',

          'help': "display more information."}),

    )

    def run(self, args):

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

        if not args:

            mode = 'all'

        elif len(args) == 1:

            mode = args[0]

        else:

            raise BadCommandUsage('Too many arguments')

        from cubicweb.migration import ConfigurationProblem

        if mode == 'all':

            print('CubicWeb %s (%s mode)' % (cwcfg.cubicweb_version(), cwcfg.mode))

            print()

        if mode in ('all', 'config', 'configurations'):

            cwcfg.load_available_configs()

            print('Available configurations:')

            for config in CONFIGURATIONS:

                print('*', config.name)

                for line in config.__doc__.splitlines():

                    line = line.strip()

                    if not line:

                        continue

                    print('   ', line)

            print()

        if mode in ('all', 'cubes'):

            cfgpb = ConfigurationProblem(cwcfg)

            try:

                cube_names = available_cube_names(cwcfg)

                namesize = max(len(x) for x in cube_names)

            except ConfigurationError as ex:

                print('No cubes available:', ex)

            except ValueError:

                print('No cubes available')

            else:

                print('Available cubes:')

                for cube in cube_names:

                    try:

                        tinfo = cwcfg.cube_pkginfo(cube)

                        tversion = tinfo.version

                        cfgpb.add_cube(cube, tversion)

                    except (ConfigurationError, AttributeError) as ex:

                        tinfo = None

                        tversion = '[missing cube information: %s]' % ex

                    print('* %s %s' % (cube.ljust(namesize), tversion))

                    if self.config.verbose:

                        if tinfo:

                            descr = getattr(tinfo, 'description', '')

                            if not descr:

                                descr = tinfo.__doc__

                            if descr:

                                print('    ' + '    \n'.join(descr.splitlines()))

                        modes = detect_available_modes(cwcfg.cube_dir(cube))

                        print('    available modes: %s' % ', '.join(modes))

            print()

        if mode in ('all', 'instances'):

            try:

                regdir = cwcfg.instances_dir()

            except ConfigurationError as ex:

                print('No instance available:', ex)

                print()

                return

            instances = list_instances(regdir)

            if instances:

                print('Available instances (%s):' % regdir)

                for appid in instances:

                    modes = cwcfg.possible_configurations(appid)

                    if not modes:

                        print('* %s (BROKEN instance, no configuration found)' % appid)

                        continue

                    print('* %s (%s)' % (appid, ', '.join(modes)))

                    try:

                        config = cwcfg.config_for(appid, modes[0])

                    except Exception as exc:

                        print('    (BROKEN instance, %s)' % exc)

                        continue

            else:

                print('No instance available in %s' % regdir)

            print()

        if mode == 'all':

            # configuration management problem solving

            cfgpb.solve()

            if cfgpb.warnings:

                print('Warnings:\n', '\n'.join('* ' + txt for txt in cfgpb.warnings))

            if cfgpb.errors:

                print('Errors:')

                for op, cube, version, src in cfgpb.errors:

                    if op == 'add':

                        print('* cube', cube, end=' ')

                        if version:

                            print(' version', version, end=' ')

                        print('is not installed, but required by %s' % src)

                    else:

                        print(

                            '* cube %s version %s is installed, but version %s is required by %s'

                            % (cube, cfgpb.cubes[cube], version, src)

                        )

def check_options_consistency(config):

    if config.automatic and config.config_level > 0:

        raise BadCommandUsage('--automatic and --config-level should not be '

                              'used together')

class CreateInstanceCommand(Command):

    """Create an instance from a cube. This is a unified

    command which can handle web / server / all-in-one installation

    according to available parts of the software library and of the

    desired cube.

    <cube>

      the name of cube to use (list available cube names using

      the "list" command). You can use several cubes by separating

      them using comma (e.g. 'jpl,email')

    <instance>

      an identifier for the instance to create

    """

    name = 'create'

    arguments = '<cube> <instance>'

    min_args = max_args = 2

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

          }),

        ('config',

         {'short': 'c', 'type': 'choice', 'metavar': '<install type>',

          'choices': ('all-in-one', 'repository', 'pyramid'),

          'default': 'all-in-one',

          'help': 'installation type, telling which part of an instance '

          'should be installed. You can list available configurations using the'

          ' "list" command. Default to "all-in-one", e.g. an installation '

          'embedding both the RQL repository and the web server.',

          }),

        ('no-db-create',

         {'short': 'S',

          'action': 'store_true',

          'default': False,

          'help': 'stop after creation and do not continue with db-create',

          }),

    )

    def run(self, args):

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

        from logilab.common.textutils import splitstrip

        check_options_consistency(self.config)

        configname = self.config.config

        cubes, appid = args

        cubes = splitstrip(cubes)

        # get the configuration and helper

        config = cwcfg.config_for(appid, configname, creating=True)

        cubes = config.expand_cubes(cubes)

        config.init_cubes(cubes)

        helper = self.config_helper(config)

        # check the cube exists

        try:

            templdirs = [cwcfg.cube_dir(cube)

                         for cube in cubes]

        except ConfigurationError as ex:

            print(ex)

            print('\navailable cubes:', end=' ')

            print(', '.join(available_cube_names(cwcfg)))

            return

        # create the registry directory for this instance

        print('\n' + underline_title('Creating the instance %s' % appid))

        create_dir(config.apphome)

        # cubicweb-ctl configuration

        if not self.config.automatic:

            print('\n' + underline_title('Configuring the instance (%s.conf)'

                                         % configname))

            config.input_config('main', self.config.config_level)

        # configuration'specific stuff

        print()

        helper.bootstrap(cubes, self.config.automatic, self.config.config_level)

        # input for cubes specific options

        if not self.config.automatic:

            sections = set(sect.lower() for sect, opt, odict in config.all_options()

                           if 'type' in odict

                           and odict.get('level', 0) <= self.config.config_level)

            for section in sections:

                if section not in ('main', 'email', 'web'):

                    print('\n' + underline_title('%s options' % section))

                    config.input_config(section, self.config.config_level)

        # write down configuration

        config.save()