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

CubicWeb main applications controller. 

%s"""

import sys

from os import remove, listdir, system, kill, getpgid

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

from cubicweb import ConfigurationError, ExecutionError, BadCommandUsage

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:

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

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

    (0 meaning all registered applications)

    """

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

    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

        """

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

            allinstances += _allinstances

        else:

            allinstances = _allinstances

        return allinstances

    def run(self, args):

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

        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 confirm('%s application %r ?' % (self.name, appid)):

                    continue

            self.run_arg(appid)

    def run_arg(self, appid):

        cmdmeth = getattr(self, '%s_application' % 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, 'application %s not %s: %s' % (

                appid, self.actionverb, ex)

        except Exception, ex:

            import traceback

            traceback.print_exc()

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

                appid, self.actionverb, ex)

class ApplicationCommandFork(ApplicationCommand):

    """Same as `ApplicationCommand`, 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 confirm('%s application %r ?' % (self.name, appid)):

                    continue

            if forkcmd:

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

                if status:

                    sys.exit(status)

            else:

                self.run_arg(appid)

# base commands ###############################################################

class ListCommand(Command):

    """List configurations, componants and applications.

    list available configurations, installed web and server componants, and

    registered applications

    """

    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

        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:

        except ConfigurationError, ex:

            print 'No cubes available:', ex

        except ValueError:

            print 'No cubes available in %s' % cubesdir

        else:

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

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

                    continue

                templdir = join(cubesdir, cube)

                try:

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

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

        print

        try:

        except ConfigurationError, ex:

            print 'No application available:', ex

            print

            return

        instances = list_instances(regdir)

        if instances:

            print 'Available applications (%s):' % regdir

            for appid in instances:

                if not modes:

                    print '* %s (BROKEN application, no configuration found)' % appid

                    continue

                print '* %s (%s)' % (appid, ', '.join(modes))

                try:

                except Exception, exc: 

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

                    continue

        else:

            print 'No application available in %s' % regdir

        print

class CreateApplicationCommand(Command):

    """Create an application 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')

    <application>

      an identifier for the application to create

    """

    name = 'create'

    arguments = '<cube> <application>'

    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 application \

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 get_csv

        configname = self.config.config

        cubes = get_csv(pop_arg(args, 1))

        appid = pop_arg(args)

        # get the configuration and helper

        config.set_language = False

        config.init_cubes(config.expand_cubes(cubes))

        helper = self.config_helper(config)

        # check the cube exists

        try:

                         for cube in cubes]

        except ConfigurationError, ex:

            print ex

            print '\navailable cubes:',

            return

        # create the registry directory for this application

        create_dir(config.apphome)

        # load site_cubicweb from the cubes dir (if any)

        config.load_site_cubicweb()

        # cubicweb-ctl configuration

        print '** application\'s %s configuration' % configname

        print '-' * 72

        config.input_config('main', self.config.config_level)

        # configuration'specific stuff

        print

        helper.bootstrap(cubes, self.config.config_level)

        # write down configuration

        config.save()

        # handle i18n files structure

        # in the first cube given

        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 confirm('error while compiling message catalogs, '

                           'continue anyway ?'):

                print 'creation not completed'

                return

        # create the additional data directory for this application

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

            create_dir(config.appdatahome)

        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

        print

        print '*' * 72

        print 'application %s (%s) created in %r' % (appid, configname,

                                                     config.apphome)

        print

        helper.postcreate()

class DeleteApplicationCommand(Command):

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

    unregister it.

    """

    name = 'delete'

    arguments = '<application>'

    options = ()

    def run(self, args):

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

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

        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 'application %s (%s) deleted' % (appid, confignames)

# application commands ########################################################

class StartApplicationCommand(ApplicationCommand):

    """Start the given applications. If no application is given, start them all.

    <application>...

      identifiers of the applications to start. If no application is

      given, start them all.

    """

    name = 'start'

    actionverb = 'started'

    options = (

        ("debug",

         {'short': 'D', 'action' : 'store_true',

          'help': 'start server in debug mode.'}),

        ("force",

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

          'default': False,

          'help': 'start the application even if it seems to be already \

running.'}),

        ('profile',

         {'short': 'P', 'type' : 'string', 'metavar': '<stat file>',

          'default': None,

          'help': 'profile code and use the specified file to store stats',

          }),

        )

    def start_application(self, appid):

        """start the application's server"""

        # use get() since start may be used from other commands (eg upgrade)

        # without all options defined

        debug = self.get('debug')

        force = self.get('force')

        if self.get('profile'):

            config.global_set_option('profile', self.config.profile)

        helper = self.config_helper(config, cmdname='start')

        pidf = config['pid-file']

        if exists(pidf) and not force:

            msg = "%s seems to be running. Remove %s by hand if necessary or use \

the --force option."

            raise ExecutionError(msg % (appid, pidf))

        command = helper.start_command(config, debug)

        if debug: