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

import sys

import traceback

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

from cubicweb.cwconfig import CubicWebConfiguration as cwcfg, CONFIGURATIONS

from cubicweb.server import set_debug

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

from cubicweb.__pkginfo__ import version as cw_version

LOG_LEVELS = ('debug', 'info', 'warning', 'error')

DBG_FLAGS = ('RQL', 'SQL', 'REPO', 'HOOKS', 'OPS', 'SEC', 'MORE', 'ALL')

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

class InstanceCommand(Command):

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

    arguments = '<instance>'

    # enforce having one instance

    min_args = 0

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

          }

         ),

        ("loglevel",

         {'type': 'choice', 'default': None, 'metavar': '<log level>',

          'choices': LOG_LEVELS, 'short': 'l',

          'help': 'allow to specify log level for debugging (choices: %s)'

                  % (', '.join(LOG_LEVELS)),

          }

         ),

        ('dbglevel',

         {'type': 'multiple_choice', 'metavar': '<debug level>',

          'default': None,

          'choices': DBG_FLAGS,

          'help': ('Set the server debugging flags; you may choose several '

                   'values in %s; imply "debug" loglevel if loglevel is not set' % (DBG_FLAGS,)),

          }),

    )

    actionverb = None

    def run(self, args):

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

        identifiers)

        """

        if not args:

            if "CW_INSTANCE" in os.environ:

                appid = os.environ["CW_INSTANCE"]

            else:

                raise BadCommandUsage("Error: instance id is missing")

        else:

            appid = args[0]

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

        traceback_ = None

        # debugmode=True is to force to have a StreamHandler used instead of

        # writting the logs into a file in /tmp

        self.cwconfig = cwcfg.config_for(appid, debugmode=True)

        # by default loglevel is 'error' but we keep the default value to None

        # because some subcommands (e.g: pyramid) can override the loglevel in

        # certain situations if it's not explicitly set by the user and we want

        # to detect that (the "None" case)

        if self['loglevel'] is None:

            # if no loglevel is set but dbglevel is here we want to set level to debug

            if self['dbglevel']:

                init_cmdline_log_threshold(self.cwconfig, 'debug')

            else:

                init_cmdline_log_threshold(self.cwconfig, 'error')

        else:

            init_cmdline_log_threshold(self.cwconfig, self['loglevel'])

        if self['dbglevel']:

            set_debug('|'.join('DBG_' + x.upper() for x in self['dbglevel']))

        try:

            status = cmdmeth(appid) or 0

        except (ExecutionError, ConfigurationError) as ex:

            # we need to do extract this information here for pdb since it is

            # now lost in python 3 once we exit the try/catch statement

            exception_type, exception, traceback_ = sys.exc_info()

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

                appid, self.actionverb, ex))

            status = 4

        except Exception as ex:

            # idem

            exception_type, exception, traceback_ = sys.exc_info()

            traceback.print_exc()

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

                appid, self.actionverb, ex))

            status = 8

        except (KeyboardInterrupt, SystemExit) as ex:

            # idem

            exception_type, exception, traceback_ = sys.exc_info()

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

            if isinstance(ex, KeyboardInterrupt):

                status = 2  # specific error code

            else:

                status = ex.code

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

            pdb = utils.get_pdb()

            if traceback_ is not None:

                pdb.post_mortem(traceback_)

            else:

                print("WARNING: Could not access to the traceback because the command return "

                      "code is different than 0 but the command didn't raised an exception.")

                # we can't use "header=" of set_trace because ipdb doesn't supports it

                pdb.set_trace()

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

          }),