cubicweb: comparison server/serverctl.py

equal deleted inserted replaced

-:500ca81a344a
+:ba9759972b52
 cnx.set_isolation_level(0)
 except AttributeError:
 # set_isolation_level() is psycopg specific
 pass
 return cnx
 def generate_sources_file(sourcesfile, sourcescfg, keys=None):
 """serialize repository'sources configuration into a INI like file
 the `keys` parameter may be used to sort sections
 """
 sconfig = sourcescfg[uri]
 if isinstance(sconfig, dict):
 # get a Configuration object
 _sconfig = Configuration(options=SOURCE_TYPES[sconfig['adapter']].options)
 for attr, val in sconfig.items():
 if attr == 'uri':
 continue
 if attr == 'adapter':
 _sconfig.adapter = val
 else:
 _sconfig.set_option(attr, val)
 try:
 return in_memory_cnx(config, login, pwd)
 except AuthenticationError:
 print 'wrong user/password'
 login, pwd = manager_userpasswd()
 # repository specific command handlers ########################################
 class RepositoryCreateHandler(CommandHandler):
 cmdname = 'create'
 cfgname = 'repository'
 sourcescfg['admin'] = sconfig
 generate_sources_file(sourcesfile, sourcescfg, ['admin', 'system'])
 restrict_perms_to_user(sourcesfile)
 # remember selected cubes for later initialization of the database
 config.write_bootstrap_cubes_file(cubes)
 def postcreate(self):
 if confirm('do you want to create repository\'s system database?'):
 verbosity = (self.config.mode == 'installed') and 'y' or 'n'
 cmd_run('db-create', self.config.appid, '--verbose=%s' % verbosity)
 else:
 print 'nevermind, you can do it later using the db-create command'
 USER_OPTIONS =  (
 ('login', {'type' : 'string',
 'default': REQUIRED,
 'help': "cubicweb manager account's login "
 '(this user will be created)',
 cnx.commit()
 except:
 cnx.rollback()
 raise
 class RepositoryStartHandler(CommandHandler):
 cmdname = 'start'
 cfgname = 'repository'
 def start_command(self, ctlconf, debug):
 command = ['cubicweb-ctl start-repository ']
 if debug:
 command.append('--debug')
 command.append(self.config.appid)
 return ' '.join(command)
 class RepositoryStopHandler(CommandHandler):
 cmdname = 'stop'
 cfgname = 'repository'
 unregistered
 """
 if self.config.pyro_enabled():
 from cubicweb.server.repository import pyro_unregister
 pyro_unregister(self.config)
 # repository specific commands ################################################
 class CreateApplicationDBCommand(Command):
 """Create the system database of an application (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>
 the identifier of the application to initialize.
 """
 name = 'db-create'
 arguments = '<application>'
 options = (
 ("create-db",
 {'short': 'c', 'type': "yn", 'metavar': '<y or n>',
 'default': True,
 'help': 'create the database (yes by default)'}),
 dbcnx.commit()
 print 'database %s created' % source['db-name']
 except:
 dbcnx.rollback()
 raise
 cnx = system_source_cnx(source, special_privs='LANGUAGE C', verbose=verbose)
 cursor = cnx.cursor()
 indexer = get_indexer(driver)
 indexer.init_extensions(cursor)
 # postgres specific stuff
 if driver == 'postgres':
 # install plpythonu/plpgsql language if not installed by the cube
 for extlang in ('plpythonu', 'plpgsql'):
 helper.create_language(cursor, extlang)
 cursor.close()
 if confirm('do you want to initialize the system database?'):
 cmd_run('db-init', config.appid)
 else:
 print 'nevermind, you can do it later using the db-init command'
 class InitApplicationCommand(Command):
 """Initialize the system database of an application (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>
 the identifier of the application to initialize.
 """
 name = 'db-init'
 arguments = '<application>'
 options = (
 ("drop",
 {'short': 'd', 'action': 'store_true',
 'default': False,
 'help': 'insert drop statements to remove previously existant \
 init_repository(config, drop=self.config.drop)
 class GrantUserOnApplicationCommand(Command):
 """Grant a database user on a repository system database.
 <application>
 the identifier of the application
 <user>
 the database's user requiring grant access
 """
 name = 'db-grant-user'
 arguments = '<application> <user>'
 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):
 else:
 cnx.commit()
 print 'grants given to %s on application %s' % (appid, user)
 class StartRepositoryCommand(Command):
 """Start an CubicWeb RQL server for a given application.
 The server will be accessible through pyro
 <application>
 the identifier of the application to initialize.
 """
 name = 'start-repository'
 arguments = '<application>'
 options = (
 ("debug",
 {'short': 'D', 'action' : 'store_true',
 'help': 'start server in debug mode.'}),
 )
 continue
 try:
 applversion = vcconf[cube]
 except KeyError:
 print "no cube version information for %s in version configuration" % cube
 continue
 if softversion == applversion:
 continue
 if softversion > applversion:
 return 'needsoftupgrade'
 elif softversion < applversion:
 return 'needapplupgrade'
 return None
 class DBDumpCommand(Command):
 """Backup the system database of an application.
 <application>
 the identifier of the application to backup
 format [[user@]host:]appname
 """
 name = 'db-dump'
 arguments = '<application>'
 options = (
 ("output",
 {'short': 'o', 'type' : "string", 'metavar' : '<file>',
 'default' : None,
 'help': 'Specify the backup file where the backup will be stored.'}
 ),
 ('sudo',
 {'short': 's', 'action' : 'store_true',
 _local_dump(appid, self.config.output)
 class DBRestoreCommand(Command):
 """Restore the system database of an application.
 <application>
 the identifier of the application to restore
 """
 name = 'db-restore'
 arguments = '<application> <backupfile>'
 options = (
 ("no-drop",
 {'short': 'n', 'action' : 'store_true',
 'default' : False,
 'help': 'for some reason the database doesn\'t exist and so '
 'should not be dropped.'}
 ),
 )
 _local_restore(appid, backupfile, not self.config.no_drop)
 class DBCopyCommand(Command):
 """Copy the system database of an application (backup and restore).
 <src-application>
 the identifier of the application to backup
 format [[user@]host:]appname
 <dest-application>
 name = 'db-copy'
 arguments = '<src-application> <dest-application>'
 options = (
 ("no-drop",
 {'short': 'n', 'action' : 'store_true',
 'default' : False,
 'help': 'For some reason the database doesn\'t exist and so '
 'should not be dropped.'}
 ),
 ("keep-dump",
 if self.config.keep_dump:
 print 'you can get the dump file at', output
 else:
 os.remove(output)
 class CheckRepositoryCommand(Command):
 """Check integrity of the system database of an application.
 <application>
 the identifier of the application to check
 """
 name = 'db-check'
 arguments = '<application>'
 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 \
 checks, i.e. entities, relations, text_index and metadata.'}
 ),
 ("autofix",
 {'short': 'a', 'type' : "yn", 'metavar' : '<yes or no>',
 'default' : False,
 'help': 'Automatically correct integrity problems if this option \
 is set to "y" or "yes", else only display them'}
 ),
 ("reindex",
 {'short': 'r', 'type' : "yn", 'metavar' : '<yes or no>',
 'default' : False,
 'help': 're-indexes the database for full text search if this \
 option is set to "y" or "yes" (may be long for large database).'}
 ),
 )
 def run(self, args):
 from cubicweb.server.checkintegrity import check
 appid = pop_arg(args, 1, msg="No application specified !")
 self.config.checks, self.config.reindex, self.config.autofix)
 class RebuildFTICommand(Command):
 """Rebuild the full-text index of the system database of an application.
 <application>
 the identifier of the application to rebuild
 """
 name = 'db-rebuild-fti'
 arguments = '<application>'
 repo, cnx = repo_cnx(config)
 session = repo._get_session(cnx.sessionid, setpool=True)
 reindex_entities(repo.schema, session)
 cnx.commit()
 class SynchronizeApplicationSchemaCommand(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>
 the identifier of the application to synchronize.
 config = ServerConfiguration.config_for(appid)
 mih = config.migration_handler()
 mih.cmd_synchronize_schema()
 register_commands( (CreateApplicationDBCommand,
 InitApplicationCommand,
 GrantUserOnApplicationCommand,
 StartRepositoryCommand,
 DBDumpCommand,
 DBRestoreCommand,

branch	tls-sprint
changeset 1469	ba9759972b52
parent 1263	01152fffd593
child 1682	36bd5cba09de