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

"""

__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

from warnings import warn

from os import remove, listdir, system, pathsep

from os.path import exists, join, isfile, isdir, dirname, abspath

from urlparse import urlparse

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 cubicweb import ConfigurationError, ExecutionError, BadCommandUsage

from cubicweb.utils import support_args

from cubicweb.cwconfig import CubicWebConfiguration as cwcfg, CWDEV, CONFIGURATIONS

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

from cubicweb.__pkginfo__ import version

if support_args(CommandLine, 'check_duplicated_command'):

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

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

                        version=version, check_duplicated_command=False)

else:

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

                        version=version)

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

class InstanceCommand(Command):

    """base class for command taking 0 to n instance id as arguments

    (0 meaning all registered instances)

    """

    arguments = '[<instance>...]'

    options = (

        ("force",

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

          'default': False,

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

          }

         ),

        )

    actionverb = None

    def ordered_instances(self):

        """return instances in the order in which they should be started,

        considering $REGISTRY_DIR/startorder file if it exists (useful when

        some instances depends on another as external source).

        Instance used by another one should appears first in the file (one

        instance per line)

        """

        regdir = cwcfg.instances_dir()

        _allinstances = list_instances(regdir)

        if isfile(join(regdir, 'startorder')):

            allinstances = []

            for line in file(join(regdir, 'startorder')):

                line = line.strip()

                if line and not line.startswith('#'):

                    try:

                        _allinstances.remove(line)

                        allinstances.append(line)

                    except ValueError:

                        print ('ERROR: startorder file contains unexistant '

                               'instance %s' % line)

            allinstances += _allinstances

        else:

            allinstances = _allinstances

        return allinstances

    def run(self, args):

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

        identifiers)

        """

        if not args:

            args = self.ordered_instances()

            try:

                askconfirm = not self.config.force

            except AttributeError:

                # no force option

                askconfirm = False

        else:

            askconfirm = False

        self.run_args(args, askconfirm)

    def run_args(self, args, askconfirm):

        status = 0

        for appid in args:

            if askconfirm:

                print '*'*72

                if not ASK.confirm('%s instance %r ?' % (self.name, appid)):

                    continue

            try:

                status = max(status, self.run_arg(appid))

            except (KeyboardInterrupt, SystemExit):

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

                return 2 # specific error code

        sys.exit(status)

    def run_arg(self, appid):

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

        try:

            status = cmdmeth(appid)

        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

        return status

class InstanceCommandFork(InstanceCommand):

    """Same as `InstanceCommand`, but command is forked in a new environment

    for each argument

    """

    def run_args(self, args, askconfirm):

        if len(args) > 1:

            forkcmd = ' '.join(w for w in sys.argv if not w in args)

        else:

            forkcmd = None

        for appid in args:

            if askconfirm:

                print '*'*72

                if not ASK.confirm('%s instance %r ?' % (self.name, appid)):

                    continue

            if forkcmd:

                status = system('%s %s' % (forkcmd, appid))

                if status:

                    print '%s exited with status %s' % (forkcmd, status)

            else:

                self.run_arg(appid)

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

            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:

                cubesdir = pathsep.join(cwcfg.cubes_search_path())

                namesize = max(len(x) for x in cwcfg.available_cubes())

            except ConfigurationError as ex:

                print 'No cubes available:', ex

            except ValueError:

                print 'No cubes available in %s' % cubesdir

            else:

                print 'Available cubes (%s):' % cubesdir

                for cube in cwcfg.available_cubes():

                    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 = getattr(tinfo, 'short_desc', '')

                                if descr:

                                    warn('[3.8] short_desc is deprecated, update %s'

                                         ' pkginfo' % cube, DeprecationWarning)

                                else:

                                    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,

                        if version:

                            print ' version', version,

                        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 an 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', 'twisted'),

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