cubicweb: comparison cwctl.py

equal deleted inserted replaced

-:b6753521129d
+:1294a6bdf3bf
 """%%prog %s [options] %s
-CubicWeb main applications controller.
+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, kill, getpgid, pathsep
 modes.append('web ui')
 break
 return modes
-class ApplicationCommand(Command):
+class InstanceCommand(Command):
-"""base class for command taking 0 to n application id as arguments
+"""base class for command taking 0 to n instance id as arguments
-(0 meaning all registered applications)
+(0 meaning all registered instances)
 """
-arguments = '[<application>...]'
+arguments = '[<instance>...]'
 options = (
 ("force",
 {'short': 'f', 'action' : 'store_true',
 'default': False,
 'help': 'force command without asking confirmation',
 else:
 allinstances = _allinstances
 return allinstances
 def run(self, args):
-"""run the <command>_method on each argument (a list of application
+"""run the <command>_method on each argument (a list of instance
 identifiers)
 """
 if not args:
 args = self.ordered_instances()
 try:
 def run_args(self, args, askconfirm):
 for appid in args:
 if askconfirm:
 print '*'*72
-if not confirm('%s application %r ?' % (self.name, appid)):
+if not confirm('%s instance %r ?' % (self.name, appid)):
 continue
 self.run_arg(appid)
 def run_arg(self, appid):
-cmdmeth = getattr(self, '%s_application' % self.name)
+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, 'application %s not %s: %s' % (
+print >> sys.stderr, 'instance %s not %s: %s' % (
 appid, self.actionverb, ex)
 except Exception, ex:
 import traceback
 traceback.print_exc()
-print >> sys.stderr, 'application %s not %s: %s' % (
+print >> sys.stderr, 'instance %s not %s: %s' % (
 appid, self.actionverb, ex)
-class ApplicationCommandFork(ApplicationCommand):
+class InstanceCommandFork(InstanceCommand):
-"""Same as `ApplicationCommand`, but command is forked in a new environment
+"""Same as `InstanceCommand`, but command is forked in a new environment
 for each argument
 """
 def run_args(self, args, askconfirm):
 if len(args) > 1:
 else:
 forkcmd = None
 for appid in args:
 if askconfirm:
 print '*'*72
-if not confirm('%s application %r ?' % (self.name, appid)):
+if not 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)
 self.run_arg(appid)
 # base commands ###############################################################
 class ListCommand(Command):
-"""List configurations, componants and applications.
+"""List configurations, cubes and instances.
-list available configurations, installed web and server componants, and
+list available configurations, installed cubes, and registered instances
-registered applications
 """
 name = 'list'
 options = (
 ('verbose',
 {'short': 'v', 'action' : 'store_true',
 print '    available modes: %s' % ', '.join(modes)
 print
 try:
 regdir = cwcfg.registry_dir()
 except ConfigurationError, ex:
-print 'No application available:', ex
+print 'No instance available:', ex
 print
 return
 instances = list_instances(regdir)
 if instances:
-print 'Available applications (%s):' % regdir
+print 'Available instances (%s):' % regdir
 for appid in instances:
 modes = cwcfg.possible_configurations(appid)
 if not modes:
-print '* %s (BROKEN application, no configuration found)' % appid
+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 application, %s)' % exc
+print '    (BROKEN instance, %s)' % exc
 continue
 else:
-print 'No application available in %s' % regdir
+print 'No instance available in %s' % regdir
 print
-class CreateApplicationCommand(Command):
+class CreateInstanceCommand(Command):
-"""Create an application from a cube. This is an unified
+"""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')
-<application>
+<instance>
-an identifier for the application to create
+an identifier for the instance to create
 """
 name = 'create'
-arguments = '<cube> <application>'
+arguments = '<cube> <instance>'
 options = (
 ("config-level",
 {'short': 'l', 'type' : 'int', 'metavar': '<level>',
 'default': 0,
 'help': 'configuration level (0..2): 0 will ask for essential \
 ),
 ("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 \
+'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.',
 }
 ),
 except ConfigurationError, ex:
 print ex
 print '\navailable cubes:',
 print ', '.join(cwcfg.available_cubes())
 return
-# create the registry directory for this application
+# create the registry directory for this instance
-print '\n'+underline_title('Creating the application %s' % appid)
+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 application (%s.conf)' % configname)
+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
 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
+# create the additional data directory for this instance
 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
 chown(config.appdatahome, config['uid'])
 print '\n-> creation done for %r.\n' % config.apphome
 helper.postcreate()
-class DeleteApplicationCommand(Command):
+class DeleteInstanceCommand(Command):
-"""Delete an application. Will remove application's files and
+"""Delete an instance. Will remove instance's files and
 unregister it.
 """
 name = 'delete'
-arguments = '<application>'
+arguments = '<instance>'
 options = ()
 def run(self, args):
 """run the command with its specific arguments"""
-appid = pop_arg(args, msg="No application specified !")
+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:
 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)
+print 'instance %s (%s) deleted' % (appid, confignames)
-# application commands ########################################################
+# instance commands ########################################################
-class StartApplicationCommand(ApplicationCommand):
+class StartInstanceCommand(InstanceCommand):
-"""Start the given applications. If no application is given, start them all.
+"""Start the given instances. If no instance is given, start them all.
-<application>...
+<instance>...
-identifiers of the applications to start. If no application is
+identifiers of the instances to start. If no instance is
 given, start them all.
 """
 name = 'start'
 actionverb = 'started'
 options = (
 {'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 \
+'help': 'start the instance 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):
+def start_instance(self, appid):
-"""start the application's server"""
+"""start the instance'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')
 config = cwcfg.config_for(appid)
 command = helper.start_command(config, debug)
 if debug:
 print "starting server with command :"
 print command
 if system(command):
-print 'an error occured while starting the application, not started'
+print 'an error occured while starting the instance, not started'
 print
 return False
 if not debug:
-print 'application %s started' % appid
+print 'instance %s started' % appid
 return True
-class StopApplicationCommand(ApplicationCommand):
+class StopInstanceCommand(InstanceCommand):
-"""Stop the given applications.
+"""Stop the given instances.
-<application>...
+<instance>...
-identifiers of the applications to stop. If no application is
+identifiers of the instances to stop. If no instance is
 given, stop them all.
 """
 name = 'stop'
 actionverb = 'stopped'
 def ordered_instances(self):
-instances = super(StopApplicationCommand, self).ordered_instances()
+instances = super(StopInstanceCommand, self).ordered_instances()
 instances.reverse()
 return instances
-def stop_application(self, appid):
+def stop_instance(self, appid):
-"""stop the application's server"""
+"""stop the instance's server"""
 config = cwcfg.config_for(appid)
 helper = self.config_helper(config, cmdname='stop')
 helper.poststop() # do this anyway
 pidf = config['pid-file']
 if not exists(pidf):
 try:
 remove(pidf)
 except OSError:
 # already removed by twistd
 pass
-print 'application %s stopped' % appid
+print 'instance %s stopped' % appid
-class RestartApplicationCommand(StartApplicationCommand,
+class RestartInstanceCommand(StartInstanceCommand,
-StopApplicationCommand):
+StopInstanceCommand):
-"""Restart the given applications.
+"""Restart the given instances.
-<application>...
+<instance>...
-identifiers of the applications to restart. If no application is
+identifiers of the instances to restart. If no instance is
 given, restart them all.
 """
 name = 'restart'
 actionverb = 'restarted'
 def run_args(self, args, askconfirm):
 regdir = cwcfg.registry_dir()
 if not isfile(join(regdir, 'startorder')) or len(args) <= 1:
 # no specific startorder
-super(RestartApplicationCommand, self).run_args(args, askconfirm)
+super(RestartInstanceCommand, self).run_args(args, askconfirm)
 return
 print ('some specific start order is specified, will first stop all '
-'applications then restart them.')
+'instances then restart them.')
 # get instances in startorder
 stopped = []
 for appid in args:
 if askconfirm:
 print '*'*72
-if not confirm('%s application %r ?' % (self.name, appid)):
+if not confirm('%s instance %r ?' % (self.name, appid)):
 continue
-self.stop_application(appid)
+self.stop_instance(appid)
 stopped.append(appid)
 forkcmd = [w for w in sys.argv if not w in args]
 forkcmd[1] = 'start'
 forkcmd = ' '.join(forkcmd)
 for appid in reversed(args):
 status = system('%s %s' % (forkcmd, appid))
 if status:
 sys.exit(status)
-def restart_application(self, appid):
+def restart_instance(self, appid):
-self.stop_application(appid)
+self.stop_instance(appid)
-if self.start_application(appid):
+if self.start_instance(appid):
-print 'application %s %s' % (appid, self.actionverb)
+print 'instance %s %s' % (appid, self.actionverb)
-class ReloadConfigurationCommand(RestartApplicationCommand):
+class ReloadConfigurationCommand(RestartInstanceCommand):
-"""Reload the given applications. This command is equivalent to a
+"""Reload the given instances. This command is equivalent to a
 restart for now.
-<application>...
+<instance>...
-identifiers of the applications to reload. If no application is
+identifiers of the instances to reload. If no instance is
 given, reload them all.
 """
 name = 'reload'
-def reload_application(self, appid):
+def reload_instance(self, appid):
-self.restart_application(appid)
+self.restart_instance(appid)
-class StatusCommand(ApplicationCommand):
+class StatusCommand(InstanceCommand):
-"""Display status information about the given applications.
+"""Display status information about the given instances.
-<application>...
+<instance>...
-identifiers of the applications to status. If no application is
+identifiers of the instances to status. If no instance is
-given, get status information about all registered applications.
+given, get status information about all registered instances.
 """
 name = 'status'
 options = ()
 @staticmethod
-def status_application(appid):
+def status_instance(appid):
-"""print running status information for an application"""
+"""print running status information for an instance"""
 for mode in cwcfg.possible_configurations(appid):
 config = cwcfg.config_for(appid, mode)
 print '[%s-%s]' % (appid, mode),
 try:
 pidf = config['pid-file']
 except KeyError:
-print 'buggy application, pid file not specified'
+print 'buggy instance, pid file not specified'
 continue
 if not exists(pidf):
 print "doesn't seem to be running"
 continue
 pid = int(open(pidf).read().strip())
 print "should be running with pid %s but the process can not be found" % pid
 continue
 print "running with pid %s" % (pid)
-class UpgradeApplicationCommand(ApplicationCommandFork,
+class UpgradeInstanceCommand(InstanceCommandFork,
-StartApplicationCommand,
+StartInstanceCommand,
-StopApplicationCommand):
+StopInstanceCommand):
-"""Upgrade an application after cubicweb and/or component(s) upgrade.
+"""Upgrade an instance after cubicweb and/or component(s) upgrade.
 For repository update, you will be prompted for a login / password to use
 to connect to the system database.  For some upgrades, the given user
 should have create or alter table permissions.
-<application>...
+<instance>...
-identifiers of the applications to upgrade. If no application is
+identifiers of the instances to upgrade. If no instance is
 given, upgrade them all.
 """
 name = 'upgrade'
 actionverb = 'upgraded'
-options = ApplicationCommand.options + (
+options = InstanceCommand.options + (
 ('force-componant-version',
 {'short': 't', 'type' : 'csv', 'metavar': 'cube1=X.Y.Z,cube2=X.Y.Z',
 'default': None,
 'help': 'force migration from the indicated  version for the specified cube.'}),
 ('force-cubicweb-version',
 'help': 'only upgrade files on the file system, not the database.'}),
 ('nostartstop',
 {'short': 'n', 'action' : 'store_true',
 'default': False,
-'help': 'don\'t try to stop application before migration and to restart it after.'}),
+'help': 'don\'t try to stop instance before migration and to restart it after.'}),
 ('verbosity',
 {'short': 'v', 'type' : 'int', 'metavar': '<0..2>',
 'default': 1,
 'help': "0: no confirmation, 1: only main commands confirmed, 2 ask \
 for everything."}),
 ('backup-db',
 {'short': 'b', 'type' : 'yn', 'metavar': '<y or n>',
 'default': None,
-'help': "Backup the application database before upgrade.\n"\
+'help': "Backup the instance database before upgrade.\n"\
 "If the option is ommitted, confirmation will be ask.",
 }),
 ('ext-sources',
 {'short': 'E', 'type' : 'csv', 'metavar': '<sources>',
 (recommended). If 'all' is given, will connect to all defined sources.",
 }),
 )
 def ordered_instances(self):
-# need this since mro return StopApplicationCommand implementation
+# need this since mro return StopInstanceCommand implementation
-return ApplicationCommand.ordered_instances(self)
+return InstanceCommand.ordered_instances(self)
-def upgrade_application(self, appid):
+def upgrade_instance(self, appid):
 from logilab.common.changelog import Version
 config = cwcfg.config_for(appid)
 config.repairing = True # notice we're not starting the server
 config.verbosity = self.config.verbosity
 try:
 config.set_sources_mode(self.config.ext_sources or ('migration',))
 except AttributeError:
 # not a server config
 pass
-# get application and installed versions for the server and the componants
+# get instance and installed versions for the server and the componants
 print 'getting versions configuration from the repository...'
 mih = config.migration_handler()
 repo = mih.repo_connect()
 vcconf = repo.get_versions()
 print 'done'
 else:
 applcubicwebversion = vcconf.get('cubicweb')
 if cubicwebversion > applcubicwebversion:
 toupgrade.append(('cubicweb', applcubicwebversion, cubicwebversion))
 if not self.config.fs_only and not toupgrade:
-print 'no software migration needed for application %s' % appid
+print 'no software migration needed for instance %s' % appid
 return
 for cube, fromversion, toversion in toupgrade:
 print '**** %s migration %s -> %s' % (cube, fromversion, toversion)
 # only stop once we're sure we have something to do
 if not (cwcfg.mode == 'dev' or self.config.nostartstop):
-self.stop_application(appid)
+self.stop_instance(appid)
 # run cubicweb/componants migration scripts
 mih.migrate(vcconf, reversed(toupgrade), self.config)
 # rewrite main configuration file
 mih.rewrite_configuration()
 # handle i18n upgrade:
 'continue anyway ?'):
 print 'migration not completed'
 return
 mih.shutdown()
 print
-print 'application migrated'
+print 'instance migrated'
 if not (cwcfg.mode == 'dev' or self.config.nostartstop):
-self.start_application(appid)
+self.start_instance(appid)
 print
 class ShellCommand(Command):
 """Run an interactive migration shell. This is a python shell with
 enhanced migration commands predefined in the namespace. An additional
 argument may be given corresponding to a file containing commands to
 execute in batch mode.
-<application>
+<instance>
-the identifier of the application to connect.
+the identifier of the instance to connect.
 """
 name = 'shell'
-arguments = '<application> [batch command file]'
+arguments = '<instance> [batch command file]'
 options = (
 ('system-only',
 {'short': 'S', 'action' : 'store_true',
 'default': False,
 'help': 'only connect to the system source when the instance is '
 sources for migration will be automatically selected.",
 }),
 )
 def run(self, args):
-appid = pop_arg(args, 99, msg="No application specified !")
+appid = pop_arg(args, 99, msg="No instance specified !")
 config = cwcfg.config_for(appid)
 if self.config.ext_sources:
 assert not self.config.system_only
 sources = self.config.ext_sources
 elif self.config.system_only:
 else:
 mih.interactive_shell()
 mih.shutdown()
-class RecompileApplicationCatalogsCommand(ApplicationCommand):
+class RecompileInstanceCatalogsCommand(InstanceCommand):
-"""Recompile i18n catalogs for applications.
+"""Recompile i18n catalogs for instances.
-<application>...
+<instance>...
-identifiers of the applications to consider. If no application is
+identifiers of the instances to consider. If no instance is
-given, recompile for all registered applications.
+given, recompile for all registered instances.
 """
 name = 'i18ninstance'
 @staticmethod
-def i18ninstance_application(appid):
+def i18ninstance_instance(appid):
-"""recompile application's messages catalogs"""
+"""recompile instance's messages catalogs"""
 config = cwcfg.config_for(appid)
 try:
 config.bootstrap_cubes()
 except IOError, ex:
 import errno
 if ex.errno != errno.ENOENT:
 raise
 # bootstrap_cubes files doesn't exist
-# set creating to notify this is not a regular start
+# notify this is not a regular start
-config.creating = True
+config.repairing = True
 # create an in-memory repository, will call config.init_cubes()
 config.repository()
 except AttributeError:
 # web only config
 config.init_cubes(config.repository().get_cubes())
 """run the command with its specific arguments"""
 for cube in cwcfg.available_cubes():
 print cube
 register_commands((ListCommand,
-CreateApplicationCommand,
+CreateInstanceCommand,
-DeleteApplicationCommand,
+DeleteInstanceCommand,
-StartApplicationCommand,
+StartInstanceCommand,
-StopApplicationCommand,
+StopInstanceCommand,
-RestartApplicationCommand,
+RestartInstanceCommand,
 ReloadConfigurationCommand,
 StatusCommand,
-UpgradeApplicationCommand,
+UpgradeInstanceCommand,
 ShellCommand,
-RecompileApplicationCatalogsCommand,
+RecompileInstanceCatalogsCommand,
 ListInstancesCommand, ListCubesCommand,
 ))
 def run(args):

changeset 2476	1294a6bdf3bf
parent 2473	490f88fb99b6
child 2489	37a747ad6fd4