# 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

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

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

                    appid, self.actionverb, ex))

            status = 4

        except Exception, 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

    """

    name = 'list'

    options = (

        ('verbose',

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

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

        )

    def run(self, args):

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

        if args:

            raise BadCommandUsage('Too many arguments')

        from cubicweb.migration import ConfigurationProblem

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

        print

        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

        cfgpb = ConfigurationProblem(cwcfg)

        try:

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

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

        except ConfigurationError, 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), 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

        try:

            regdir = cwcfg.instances_dir()

        except ConfigurationError, 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, exc:

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

                    continue

        else:

            print 'No instance available in %s' % regdir

        print

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

          }),

        )

    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, ex:

            print ex

            print '\navailable cubes:',

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

            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

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

                       if 'type' in odict

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

        for section in sections:

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