cubicweb: comparison server/serverctl.py

equal deleted inserted replaced

-:b6753521129d
+:1294a6bdf3bf
 return get_connection(driver, dbhost, dbname, user, password=password,
 port=source.get('db-port'))
 def system_source_cnx(source, dbms_system_base=False,
 special_privs='CREATE/DROP DATABASE', verbose=True):
-"""shortcut to get a connextion to the application system database
+"""shortcut to get a connextion to the instance system database
 defined in the given config. If <dbms_system_base> is True,
 connect to the dbms system database instead (for task such as
-create/drop the application database)
+create/drop the instance database)
 """
 if dbms_system_base:
 from logilab.common.adbh import get_adv_func_helper
 system_db = get_adv_func_helper(source['db-driver']).system_database()
 return source_cnx(source, system_db, special_privs=special_privs, verbose=verbose)
 class RepositoryCreateHandler(CommandHandler):
 cmdname = 'create'
 cfgname = 'repository'
 def bootstrap(self, cubes, inputlevel=0):
-"""create an application by copying files from the given cube and by
+"""create an instance by copying files from the given cube and by
 asking information necessary to build required configuration files
 """
 config = self.config
 print underline_title('Configuring the repository')
 config.input_config('email', inputlevel)
 class RepositoryDeleteHandler(CommandHandler):
 cmdname = 'delete'
 cfgname = 'repository'
 def cleanup(self):
-"""remove application's configuration and database"""
+"""remove instance's configuration and database"""
 from logilab.common.adbh import get_adv_func_helper
 source = self.config.sources()['system']
 dbname = source['db-name']
 helper = get_adv_func_helper(source['db-driver'])
 if confirm('Delete database %s ?' % dbname):
 from cubicweb.server.repository import pyro_unregister
 pyro_unregister(self.config)
 # repository specific commands ################################################
-class CreateApplicationDBCommand(Command):
+class CreateInstanceDBCommand(Command):
-"""Create the system database of an application (run after 'create').
+"""Create the system database of an instance (run after 'create').
 You will be prompted for a login / password to use to connect to
 the system database.  The given user should have almost all rights
 on the database (ie a super user on the dbms allowed to create
 database, users, languages...).
-<application>
+<instance>
-the identifier of the application to initialize.
+the identifier of the instance to initialize.
 """
 name = 'db-create'
-arguments = '<application>'
+arguments = '<instance>'
 options = (
 ("create-db",
 {'short': 'c', 'type': "yn", 'metavar': '<y or n>',
 'default': True,
 def run(self, args):
 """run the command with its specific arguments"""
 from logilab.common.adbh import get_adv_func_helper
 from indexer import get_indexer
 verbose = self.get('verbose')
-appid = pop_arg(args, msg="No application specified !")
+appid = pop_arg(args, msg="No instance specified !")
 config = ServerConfiguration.config_for(appid)
 create_db = self.config.create_db
 source = config.sources()['system']
 driver = source['db-driver']
 helper = get_adv_func_helper(driver)
 # install plpythonu/plpgsql language if not installed by the cube
 for extlang in ('plpythonu', 'plpgsql'):
 helper.create_language(cursor, extlang)
 cursor.close()
 cnx.commit()
-print '-> database for application %s created and necessary extensions installed.' % appid
+print '-> database for instance %s created and necessary extensions installed.' % appid
 print
 if confirm('Do you want to run db-init to initialize the "system database" ?'):
 cmd_run('db-init', config.appid)
 else:
 print ('-> nevermind, you can do it later with '
 '"cubicweb-ctl db-init %s".' % self.config.appid)
-class InitApplicationCommand(Command):
+class InitInstanceCommand(Command):
-"""Initialize the system database of an application (run after 'db-create').
+"""Initialize the system database of an instance (run after 'db-create').
 You will be prompted for a login / password to use to connect to
 the system database.  The given user should have the create tables,
 and grant permissions.
-<application>
+<instance>
-the identifier of the application to initialize.
+the identifier of the instance to initialize.
 """
 name = 'db-init'
-arguments = '<application>'
+arguments = '<instance>'
 options = (
 ("drop",
 {'short': 'd', 'action': 'store_true',
 'default': False,
 )
 def run(self, args):
 print '\n'+underline_title('Initializing the "system database"')
 from cubicweb.server import init_repository
-appid = pop_arg(args, msg="No application specified !")
+appid = pop_arg(args, msg="No instance specified !")
 config = ServerConfiguration.config_for(appid)
 init_repository(config, drop=self.config.drop)
-class GrantUserOnApplicationCommand(Command):
+class GrantUserOnInstanceCommand(Command):
 """Grant a database user on a repository system database.
-<application>
+<instance>
-the identifier of the application
+the identifier of the instance
 <user>
 the database's user requiring grant access
 """
 name = 'db-grant-user'
-arguments = '<application> <user>'
+arguments = '<instance> <user>'
 options = (
 ("set-owner",
 {'short': 'o', 'type' : "yn", 'metavar' : '<yes or no>',
 'default' : False,
 ),
 )
 def run(self, args):
 """run the command with its specific arguments"""
 from cubicweb.server.sqlutils import sqlexec, sqlgrants
-appid = pop_arg(args, 1, msg="No application specified !")
+appid = pop_arg(args, 1, msg="No instance specified !")
 user = pop_arg(args, msg="No user specified !")
 config = ServerConfiguration.config_for(appid)
 source = config.sources()['system']
 set_owner = self.config.set_owner
 cnx = system_source_cnx(source, special_privs='GRANT')
 import traceback
 traceback.print_exc()
 print '-> an error occured:', ex
 else:
 cnx.commit()
-print '-> rights granted to %s on application %s.' % (appid, user)
+print '-> rights granted to %s on instance %s.' % (appid, user)
 class ResetAdminPasswordCommand(Command):
 """Reset the administrator password.
-<application>
+<instance>
-the identifier of the application
+the identifier of the instance
 """
 name = 'reset-admin-pwd'
-arguments = '<application>'
+arguments = '<instance>'
 def run(self, args):
 """run the command with its specific arguments"""
 from cubicweb.server.sqlutils import sqlexec, SQL_PREFIX
 from cubicweb.server.utils import crypt_password, manager_userpasswd
-appid = pop_arg(args, 1, msg="No application specified !")
+appid = pop_arg(args, 1, msg="No instance specified !")
 config = ServerConfiguration.config_for(appid)
 sourcescfg = config.read_sources_file()
 try:
 adminlogin = sourcescfg['admin']['login']
 except KeyError:
 cnx.commit()
 print '-> password reset, sources file regenerated.'
 class StartRepositoryCommand(Command):
-"""Start an CubicWeb RQL server for a given application.
+"""Start an CubicWeb RQL server for a given instance.
 The server will be accessible through pyro
-<application>
+<instance>
-the identifier of the application to initialize.
+the identifier of the instance to initialize.
 """
 name = 'start-repository'
-arguments = '<application>'
+arguments = '<instance>'
 options = (
 ("debug",
 {'short': 'D', 'action' : 'store_true',
 'help': 'start server in debug mode.'}),
 )
 def run(self, args):
 from cubicweb.server.server import RepositoryServer
-appid = pop_arg(args, msg="No application specified !")
+appid = pop_arg(args, msg="No instance specified !")
 config = ServerConfiguration.config_for(appid)
 debug = self.config.debug
 # create the server
 server = RepositoryServer(config, debug)
 # go ! (don't daemonize in debug mode)
 if not dbversions:
 print "bad or missing version information in the database, don't upgrade file system"
 return
 # version of installed software
 eversion = dbversions['cubicweb']
-status = application_status(config, eversion, dbversions)
+status = instance_status(config, eversion, dbversions)
 # * database version > installed software
 if status == 'needsoftupgrade':
 print "database is using some earlier version than installed software!"
 print "please upgrade your software and then upgrade the instance"
 print "using command 'cubicweb-ctl upgrade %s'" % config.appid
 return
 # * database version = installed software, database version = instance fs version
 #   ok!
-def application_status(config, cubicwebapplversion, vcconf):
+def instance_status(config, cubicwebapplversion, vcconf):
 cubicwebversion = config.cubicweb_version()
 if cubicwebapplversion > cubicwebversion:
 return 'needsoftupgrade'
 if cubicwebapplversion < cubicwebversion:
 return 'needapplupgrade'
 return 'needapplupgrade'
 return None
 class DBDumpCommand(Command):
-"""Backup the system database of an application.
+"""Backup the system database of an instance.
-<application>
+<instance>
-the identifier of the application to backup
+the identifier of the instance to backup
 format [[user@]host:]appname
 """
 name = 'db-dump'
-arguments = '<application>'
+arguments = '<instance>'
 options = (
 ("output",
 {'short': 'o', 'type' : "string", 'metavar' : '<file>',
 'default' : None,
 'help': 'Use sudo on the remote host.'}
 ),
 )
 def run(self, args):
-appid = pop_arg(args, 1, msg="No application specified !")
+appid = pop_arg(args, 1, msg="No instance specified !")
 if ':' in appid:
 host, appid = appid.split(':')
 _remote_dump(host, appid, self.config.output, self.config.sudo)
 else:
 _local_dump(appid, self.config.output)
 class DBRestoreCommand(Command):
-"""Restore the system database of an application.
+"""Restore the system database of an instance.
-<application>
+<instance>
-the identifier of the application to restore
+the identifier of the instance to restore
 """
 name = 'db-restore'
-arguments = '<application> <backupfile>'
+arguments = '<instance> <backupfile>'
 options = (
 ("no-drop",
 {'short': 'n', 'action' : 'store_true',
 'default' : False,
 'should not be dropped.'}
 ),
 )
 def run(self, args):
-appid = pop_arg(args, 1, msg="No application specified !")
+appid = pop_arg(args, 1, msg="No instance specified !")
 backupfile = pop_arg(args, msg="No backup file specified !")
 _local_restore(appid, backupfile, not self.config.no_drop)
 class DBCopyCommand(Command):
-"""Copy the system database of an application (backup and restore).
+"""Copy the system database of an instance (backup and restore).
-<src-application>
+<src-instance>
-the identifier of the application to backup
+the identifier of the instance to backup
 format [[user@]host:]appname
-<dest-application>
+<dest-instance>
-the identifier of the application to restore
+the identifier of the instance to restore
 """
 name = 'db-copy'
-arguments = '<src-application> <dest-application>'
+arguments = '<src-instance> <dest-instance>'
 options = (
 ("no-drop",
 {'short': 'n', 'action' : 'store_true',
 'default' : False,
 ),
 )
 def run(self, args):
 import tempfile
-srcappid = pop_arg(args, 1, msg="No source application specified !")
+srcappid = pop_arg(args, 1, msg="No source instance specified !")
-destappid = pop_arg(args, msg="No destination application specified !")
+destappid = pop_arg(args, msg="No destination instance specified !")
 _, output = tempfile.mkstemp()
 if ':' in srcappid:
 host, srcappid = srcappid.split(':')
 _remote_dump(host, srcappid, output, self.config.sudo)
 else:
 else:
 os.remove(output)
 class CheckRepositoryCommand(Command):
-"""Check integrity of the system database of an application.
+"""Check integrity of the system database of an instance.
-<application>
+<instance>
-the identifier of the application to check
+the identifier of the instance to check
 """
 name = 'db-check'
-arguments = '<application>'
+arguments = '<instance>'
 options = (
 ("checks",
 {'short': 'c', 'type' : "csv", 'metavar' : '<check list>',
 'default' : ('entities', 'relations', 'metadata', 'schema', 'text_index'),
 )
 def run(self, args):
 from cubicweb.server.checkintegrity import check
-appid = pop_arg(args, 1, msg="No application specified !")
+appid = pop_arg(args, 1, msg="No instance specified !")
 config = ServerConfiguration.config_for(appid)
 config.repairing = self.config.force
 repo, cnx = repo_cnx(config)
 check(repo, cnx,
 self.config.checks, self.config.reindex, self.config.autofix)
 class RebuildFTICommand(Command):
-"""Rebuild the full-text index of the system database of an application.
+"""Rebuild the full-text index of the system database of an instance.
-<application>
+<instance>
-the identifier of the application to rebuild
+the identifier of the instance to rebuild
 """
 name = 'db-rebuild-fti'
-arguments = '<application>'
+arguments = '<instance>'
 options = ()
 def run(self, args):
 from cubicweb.server.checkintegrity import reindex_entities
-appid = pop_arg(args, 1, msg="No application specified !")
+appid = pop_arg(args, 1, msg="No instance specified !")
 config = ServerConfiguration.config_for(appid)
 repo, cnx = repo_cnx(config)
 session = repo._get_session(cnx.sessionid, setpool=True)
 reindex_entities(repo.schema, session)
 cnx.commit()
-class SynchronizeApplicationSchemaCommand(Command):
+class SynchronizeInstanceSchemaCommand(Command):
 """Synchronize persistent schema with cube schema.
 Will synchronize common stuff between the cube schema and the
 actual persistent schema, but will not add/remove any entity or relation.
-<application>
+<instance>
-the identifier of the application to synchronize.
+the identifier of the instance to synchronize.
 """
 name = 'schema-sync'
-arguments = '<application>'
+arguments = '<instance>'
 def run(self, args):
-appid = pop_arg(args, msg="No application specified !")
+appid = pop_arg(args, msg="No instance specified !")
 config = ServerConfiguration.config_for(appid)
 mih = config.migration_handler()
 mih.cmd_synchronize_schema()
-register_commands( (CreateApplicationDBCommand,
+register_commands( (CreateInstanceDBCommand,
-InitApplicationCommand,
+InitInstanceCommand,
-GrantUserOnApplicationCommand,
+GrantUserOnInstanceCommand,
 ResetAdminPasswordCommand,
 StartRepositoryCommand,
 DBDumpCommand,
 DBRestoreCommand,
 DBCopyCommand,
 CheckRepositoryCommand,
 RebuildFTICommand,
-SynchronizeApplicationSchemaCommand,
+SynchronizeInstanceSchemaCommand,
 ) )

changeset 2476	1294a6bdf3bf
parent 2473	490f88fb99b6
child 2493	9806571ea790