"""%%prog %s [options] %s

CubicWeb main instances controller.

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

%s"""

import sys

from os import remove, listdir, system, pathsep

try:

    from os import kill, getpgid

except ImportError:

    def kill(*args): pass

    def getpgid(): pass

from logilab.common.clcommands import register_commands, pop_arg

from logilab.common.shellutils import ASK

from cubicweb import ConfigurationError, ExecutionError, BadCommandUsage, underline_title

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

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

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

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

        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

                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

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

        cwcfg.creating = True

        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)

        # load site_cubicweb from the cubes dir (if any)

        config.load_site_cubicweb()

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

        # write down configuration

        config.save()

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

        # handle i18n files structure

        # in the first cube given

        print '-> preparing i18n catalogs'

        from cubicweb.common 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']

            chown(config.appdatahome, config['uid'])

        print '\n-> creation done for %r.\n' % config.apphome

        helper.postcreate()

class DeleteInstanceCommand(Command):

    """Delete an instance. Will remove instance's files and

    unregister it.

    """

    name = 'delete'

    arguments = '<instance>'

    options = ()

    def run(self, args):

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

        appid = pop_arg(args, msg="No instance specified !")

        configs = [cwcfg.config_for(appid, configname)

                   for configname in cwcfg.possible_configurations(appid)]

        if not configs:

            raise ExecutionError('unable to guess configuration for %s' % appid)

        for config in configs:

            helper = self.config_helper(config, required=False)

            if helper:

                helper.cleanup()

        # remove home

        rm(config.apphome)

        # remove instance data directory

        try:

            rm(config.appdatahome)

        except OSError, ex:

            import errno

            if ex.errno != errno.ENOENT:

                raise

        confignames = ', '.join([config.name for config in configs])

        print '-> instance %s (%s) deleted.' % (appid, confignames)