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

provide a pluggable commands system.

:organization: Logilab

:copyright: 2001-2010 LOGILAB S.A. (Paris, FRANCE), license is LGPL v2.

:contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr

:license: GNU Lesser General Public License, v2.1 - http://www.gnu.org/licenses

"""

__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 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 register_commands, pop_arg

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, main_run, rm, create_dir, underline_title

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

        for appid in args:

            if askconfirm:

                print '*'*72

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

                    continue

            self.run_arg(appid)

    def run_arg(self, appid):

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

        try:

            cmdmeth(appid)

        except (KeyboardInterrupt, SystemExit):

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

            sys.exit(2) # specific error code

        except (ExecutionError, ConfigurationError), ex:

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

                appid, self.actionverb, ex)

        except Exception, ex:

            import traceback

            traceback.print_exc()

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

                appid, self.actionverb, ex)

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

def version_strictly_lower(a, b):

    from logilab.common.changelog import Version

    if a:

        a = Version(a)

    if b:

        b = Version(b)

    return a < b

def max_version(a, b):

    from logilab.common.changelog import Version

    return str(max(Version(a), Version(b)))

class ConfigurationProblem(object):

    """Each cube has its own list of dependencies on other cubes/versions.

    The ConfigurationProblem is used to record the loaded cubes, then to detect

    inconsistencies in their dependencies.

    See configuration management on wikipedia for litterature.

    """

    def __init__(self):

        self.cubes = {}

    def add_cube(self, name, info):

        self.cubes[name] = info

    def solve(self):

        self.warnings = []

        self.errors = []

        self.read_constraints()

        for cube, versions in sorted(self.constraints.items()):

            oper, version = None, None

            # simplify constraints

            if versions:

                for constraint in versions:

                    op, ver = constraint

                    if oper is None:

                        oper = op

                        version = ver

                    elif op == '>=' and oper == '>=':

                        version = max_version(ver, version)

                    else:

                        print 'unable to handle this case', oper, version, op, ver

            # "solve" constraint satisfaction problem

            if cube not in self.cubes:

                self.errors.append( ('add', cube, version) )

            elif versions:

                lower_strict = version_strictly_lower(self.cubes[cube].version, version)

                if oper in ('>=','='):

                    if lower_strict:

                        self.errors.append( ('update', cube, version) )

                else:

                    print 'unknown operator', oper

    def read_constraints(self):

        self.constraints = {}

        self.reverse_constraints = {}

        for cube, info in self.cubes.items():

            if hasattr(info,'__depends_cubes__'):

                use = info.__depends_cubes__

                if not isinstance(use, dict):

                    use = dict((key, None) for key in use)

                    self.warnings.append('cube %s should define __depends_cubes__ as a dict not a list')

            else:

                self.warnings.append('cube %s should define __depends_cubes__' % cube)

                use = dict((key, None) for key in info.__use__)

            for name, constraint in use.items():

                self.constraints.setdefault(name,set())

                if constraint:

                    try:

                        oper, version = constraint.split()

                        self.constraints[name].add( (oper, version) )

                    except:

                        self.warnings.append('cube %s depends on %s but constraint badly formatted: %s'

                                             % (cube, name, constraint))

                self.reverse_constraints.setdefault(name, set()).add(cube)

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 much arguments')

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

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

                if cube in ('CVS', '.svn', 'shared', '.hg'):

                    continue

                try:

                    tinfo = cwcfg.cube_pkginfo(cube)

                    tversion = tinfo.version

                    cfgpb.add_cube(cube, tinfo)

                except ConfigurationError:

                    tinfo = None

                    tversion = '[missing cube information]'

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

                if self.config.verbose:

                    shortdesc = tinfo and (getattr(tinfo, 'short_desc', '')

                                           or tinfo.__doc__)

                    if shortdesc:

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

                    modes = detect_available_modes(cwcfg.cube_dir(cube))

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

        print

        try:

            regdir = cwcfg.registry_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, 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>'

    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 = splitstrip(pop_arg(args, 1))

        appid = pop_arg(args)

        # get the configuration and helper