# copyright 2003-2010 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 os.path import exists, join, isfile, isdir, dirname, abspath

from logilab.common.clcommands import CommandLine

from logilab.common.shellutils import ASK

from cubicweb import ConfigurationError, ExecutionError, BadCommandUsage

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

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

from cubicweb.__pkginfo__ import version

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

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

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

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

        sys.exit(status)

    def run_arg(self, appid):

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

        try:

            status = cmdmeth(appid)

        except (KeyboardInterrupt, SystemExit):

            print >> sys.stderr, '%s aborted' % self.name

            return 2 # specific error code

        except (ExecutionError, ConfigurationError), ex:

            print >> sys.stderr, 'instance %s not %s: %s' % (

                appid, self.actionverb, ex)

            status = 4

        except Exception, ex:

            import traceback

            traceback.print_exc()

            print >> sys.stderr, 'instance %s not %s: %s' % (

                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:

                    tinfo = None

                    tversion = '[missing cube information]'

                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 in cfgpb.errors:

                if op == 'add':

                    print '* cube', cube,

                    if version:

                        print ' version', version,

                    print 'is not installed, but required by %s' % ' '.join(cfgpb.reverse_constraints[cube])

                else:

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

                        cube, cfgpb.cubes[cube], version, ', '.join(cfgpb.reverse_constraints[cube]))

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

    <instance>

      an identifier for the instance to create

    """

    name = 'create'

    arguments = '<cube> <instance>'

    min_args = max_args = 2

    options = (

        ("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

        configname = self.config.config

        cubes, appid = args

        cubes = splitstrip(cubes)

        # get the configuration and helper

        config = cwcfg.config_for(appid, configname)

        config.set_language = False

        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

        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.config_level)

        # input for cubes specific options

        for section in set(sect.lower() for sect, opt, optdict in config.all_options()

                           if optdict.get('level') <= self.config.config_level):

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

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

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

        # write down configuration

        config.save()

        self._handle_win32(config, appid)

        print '-> generated %s' % config.main_config_file()

        # handle i18n files structure

        # in the first cube given

        print '-> preparing i18n catalogs'

        from cubicweb import i18n

        langs = [lang for lang, _ in i18n.available_catalogs(join(templdirs[0], 'i18n'))]

        errors = config.i18ncompile(langs)

        if errors:

            print '\n'.join(errors)

            if not ASK.confirm('error while compiling message catalogs, '

                               'continue anyway ?'):

                print 'creation not completed'

                return

        # create the additional data directory for this instance

        if config.appdatahome != config.apphome: # true in dev mode

            create_dir(config.appdatahome)

        create_dir(join(config.appdatahome, 'backup'))

        if config['uid']:

            from logilab.common.shellutils import chown

            # this directory should be owned by the uid of the server process

            print 'set %s as owner of the data directory' % config['uid']