cubicweb: comparison server/serverctl.py

equal deleted inserted replaced

-:27c47d239739
+:f76599a96238
 # completion). So import locally in command helpers.
 import sys
 import os
 from logilab.common.configuration import Configuration
-from logilab.common.clcommands import register_commands, cmd_run, pop_arg
 from logilab.common.shellutils import ASK
 from cubicweb import AuthenticationError, ExecutionError, ConfigurationError
 from cubicweb.toolsutils import Command, CommandHandler, underline_title
+from cubicweb.cwctl import CWCTL
 from cubicweb.server import SOURCE_TYPES
 from cubicweb.server.serverconfig import (USER_OPTIONS, ServerConfiguration,
 SourceConfiguration)
 # utility functions ###########################################################
 config.write_bootstrap_cubes_file(cubes)
 def postcreate(self):
 if ASK.confirm('Run db-create to create the system database ?'):
 verbosity = (self.config.mode == 'installed') and 'y' or 'n'
-cmd_run('db-create', self.config.appid, '--verbose=%s' % verbosity)
+CWCTL.run(['db-create', self.config.appid, '--verbose=%s' % verbosity])
 else:
 print ('-> nevermind, you can do it later with '
 '"cubicweb-ctl db-create %s".' % self.config.appid)
 <instance>
 the identifier of the instance to initialize.
 """
 name = 'db-create'
 arguments = '<instance>'
+min_args = max_args = 1
 options = (
 ('create-db',
 {'short': 'c', 'type': 'yn', 'metavar': '<y or n>',
 'default': True,
 'help': 'create the database (yes by default)'}),
 def run(self, args):
 """run the command with its specific arguments"""
 from logilab.database import get_db_helper
 verbose = self.get('verbose')
 automatic = self.get('automatic')
-appid = pop_arg(args, msg='No instance specified !')
+appid = args.pop()
 config = ServerConfiguration.config_for(appid)
 source = config.sources()['system']
 dbname = source['db-name']
 driver = source['db-driver']
 helper = get_db_helper(driver)
 cursor.close()
 cnx.commit()
 print '-> database for instance %s created and necessary extensions installed.' % appid
 print
 if automatic or ASK.confirm('Run db-init to initialize the system database ?'):
-cmd_run('db-init', config.appid)
+CWCTL.run(['db-init', config.appid])
 else:
 print ('-> nevermind, you can do it later with '
 '"cubicweb-ctl db-init %s".' % config.appid)
 <instance>
 the identifier of the instance to initialize.
 """
 name = 'db-init'
 arguments = '<instance>'
+min_args = max_args = 1
 options = (
 ('drop',
 {'short': 'd', 'action': 'store_true',
 'default': False,
 'help': 'insert drop statements to remove previously existant \
 def run(self, args):
 print '\n'+underline_title('Initializing the system database')
 from cubicweb.server import init_repository
 from logilab.database import get_connection
-appid = pop_arg(args, msg='No instance specified !')
+appid = args[0]
 config = ServerConfiguration.config_for(appid)
 try:
 system = config.sources()['system']
 extra_args=system.get('db-extra-arguments')
 extra = extra_args and {'extra_args': extra_args} or {}
 <user>
 the database's user requiring grant access
 """
 name = 'db-grant-user'
 arguments = '<instance> <user>'
+min_args = max_args = 2
 options = (
 ('set-owner',
 {'short': 'o', 'type' : 'yn', 'metavar' : '<yes or no>',
 'default' : False,
 'help': 'Set the user as tables owner if yes (no by default).'}
 ),
 )
 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 instance specified !')
+appid, user = args
-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')
 cursor = cnx.cursor()
 set_owner=set_owner), cursor)
 except Exception, ex:
 cnx.rollback()
 import traceback
 traceback.print_exc()
-print '-> an error occured:', ex
+print '-> an error occurred:', ex
 else:
 cnx.commit()
 print '-> rights granted to %s on instance %s.' % (appid, user)
 arguments = '<instance>'
 def run(self, args):
 """run the command with its specific arguments"""
 from cubicweb.server.utils import crypt_password, manager_userpasswd
-appid = pop_arg(args, 1, msg='No instance specified !')
+appid = args[0]
 config = ServerConfiguration.config_for(appid)
 sourcescfg = config.read_sources_file()
 try:
 adminlogin = sourcescfg['admin']['login']
 except KeyError:
 config.write_sources_file(sourcescfg)
 except Exception, ex:
 cnx.rollback()
 import traceback
 traceback.print_exc()
-print '-> an error occured:', ex
+print '-> an error occurred:', ex
 else:
 cnx.commit()
 print '-> password reset, sources file regenerated.'
 cnx.close()
 <instance>
 the identifier of the instance to initialize.
 """
 name = 'start-repository'
 arguments = '<instance>'
+min_args = max_args = 1
 options = (
 ('debug',
 {'short': 'D', 'action' : 'store_true',
 'help': 'start server in debug mode.'}),
 ('loglevel',
 def run(self, args):
 from logilab.common.daemon import daemonize
 from cubicweb.cwctl import init_cmdline_log_threshold
 from cubicweb.server.server import RepositoryServer
-appid = pop_arg(args, msg='No instance specified !')
+appid = args[0]
 debug = self['debug']
 if sys.platform == 'win32' and not debug:
 from logging import getLogger
 logger = getLogger('cubicweb.ctl')
 logger.info('Forcing debug mode on win32 platform')
 if os.system(cmd):
 raise ExecutionError('Error while retrieving the dump at /tmp/%s' % filename)
 rmcmd = 'ssh -t %s "rm -f /tmp/%s"' % (host, filename)
 print rmcmd
 if os.system(rmcmd) and not ASK.confirm(
-'An error occured while deleting remote dump at /tmp/%s. '
+'An error occurred while deleting remote dump at /tmp/%s. '
 'Continue anyway?' % filename):
 raise ExecutionError('Error while deleting remote dump at /tmp/%s' % filename)
 def _local_dump(appid, output):
 config = ServerConfiguration.config_for(appid)
 the identifier of the instance to backup
 format [[user@]host:]appname
 """
 name = 'db-dump'
 arguments = '<instance>'
+min_args = max_args = 1
 options = (
 ('output',
 {'short': 'o', 'type' : 'string', 'metavar' : '<file>',
 'default' : None,
 'help': 'Specify the backup file where the backup will be stored.'}
 'help': 'Use sudo on the remote host.'}
 ),
 )
 def run(self, args):
-appid = pop_arg(args, 1, msg='No instance specified !')
+appid = args[0]
 if ':' in appid:
 host, appid = appid.split(':')
 _remote_dump(host, appid, self.config.output, self.config.sudo)
 else:
 _local_dump(appid, self.config.output)
 <instance>
 the identifier of the instance to restore
 """
 name = 'db-restore'
 arguments = '<instance> <backupfile>'
+min_args = max_args = 2
 options = (
 ('no-drop',
 {'short': 'n', 'action' : 'store_true', 'default' : False,
 'help': 'for some reason the database doesn\'t exist and so '
 'timestamp of the backup to restore, not a file'}
 ),
 )
 def run(self, args):
-appid = pop_arg(args, 1, msg='No instance specified !')
+appid, backupfile = args
-backupfile = pop_arg(args, msg='No backup file or timestamp specified !')
 _local_restore(appid, backupfile,
 drop=not self.config.no_drop,
 systemonly=not self.config.restore_all)
 <dest-instance>
 the identifier of the instance to restore
 """
 name = 'db-copy'
 arguments = '<src-instance> <dest-instance>'
+min_args = max_args = 2
 options = (
 ('no-drop',
 {'short': 'n', 'action' : 'store_true',
 'default' : False,
 'help': 'For some reason the database doesn\'t exist and so '
 ),
 )
 def run(self, args):
 import tempfile
-srcappid = pop_arg(args, 1, msg='No source instance specified !')
+srcappid, destappid = args
-destappid = pop_arg(args, msg='No destination instance specified !')
 fd, output = tempfile.mkstemp()
 os.close(fd)
 if ':' in srcappid:
 host, srcappid = srcappid.split(':')
 _remote_dump(host, srcappid, output, self.config.sudo)
 <instance>
 the identifier of the instance to check
 """
 name = 'db-check'
 arguments = '<instance>'
+min_args = max_args = 1
 options = (
 ('checks',
 {'short': 'c', 'type' : 'csv', 'metavar' : '<check list>',
 'default' : ('entities', 'relations', 'metadata', 'schema', 'text_index'),
 'help': 'Comma separated list of check to run. By default run all \
 ),
 )
 def run(self, args):
-from cubicweb.server.checkintegrity import check
+appid = args[0]
-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)
 <instance>
 the identifier of the instance to rebuild
 """
 name = 'db-rebuild-fti'
 arguments = '<instance>'
+min_args = max_args = 1
-options = ()
 def run(self, args):
 from cubicweb.server.checkintegrity import reindex_entities
-appid = pop_arg(args, 1, msg='No instance specified !')
+appid = args[0]
 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()
 <instance>
 the identifier of the instance to synchronize.
 """
 name = 'schema-sync'
 arguments = '<instance>'
+min_args = max_args = 1
-def run(self, args):
-appid = pop_arg(args, msg='No instance specified !')
+def run(self, args):
+appid = args[0]
 config = ServerConfiguration.config_for(appid)
 mih = config.migration_handler()
 mih.cmd_synchronize_schema()
-register_commands( (CreateInstanceDBCommand,
+class CheckMappingCommand(Command):
-InitInstanceCommand,
+"""Check content of the mapping file of an external source.
-GrantUserOnInstanceCommand,
-ResetAdminPasswordCommand,
+The mapping is checked against the instance's schema, searching for
-StartRepositoryCommand,
+inconsistencies or stuff you may have forgotten. It's higly recommanded to
-DBDumpCommand,
+run it when you setup a multi-sources instance.
-DBRestoreCommand,
-DBCopyCommand,
+<instance>
-CheckRepositoryCommand,
+the identifier of the instance.
-RebuildFTICommand,
-SynchronizeInstanceSchemaCommand,
+<mapping file>
-) )
+the mapping file to check.
+"""
+name = 'check-mapping'
+arguments = '<instance> <mapping file>'
+min_args = max_args = 2
+def run(self, args):
+from cubicweb.server.checkintegrity import check_mapping
+from cubicweb.server.sources.pyrorql import load_mapping_file
+appid, mappingfile = args
+config = ServerConfiguration.config_for(appid)
+config.quick_start = True
+mih = config.migration_handler(connect=False, verbosity=1)
+repo = mih.repo_connect() # necessary to get cubes
+check_mapping(config.load_schema(), load_mapping_file(mappingfile))
+for cmdclass in (CreateInstanceDBCommand, InitInstanceCommand,
+GrantUserOnInstanceCommand, ResetAdminPasswordCommand,
+StartRepositoryCommand,
+DBDumpCommand, DBRestoreCommand, DBCopyCommand,
+CheckRepositoryCommand, RebuildFTICommand,
+SynchronizeInstanceSchemaCommand,
+CheckMappingCommand,
+):
+CWCTL.register(cmdclass)

changeset 6139	f76599a96238
parent 6138	65f5e488f983
child 6184	da580218a5b3