+
−"""a class implementing basic actions used in migration scripts.
+
−
+
−The following schema actions are supported for now:
+
−* add/drop/rename attribute
+
−* add/drop entity/relation type
+
−* rename entity type
+
−
+
−The following data actions are supported for now:
+
−* add an entity
+
−* execute raw RQL queries
+
−
+
−
+
−:organization: Logilab
+
−:copyright: 2001-2009 LOGILAB S.A. (Paris, FRANCE), license is LGPL v2.
+
−:contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr
+
−:license: GNU Lesser General Public License, v2.1 - http://www.gnu.org/licenses
+
−"""
+
−__docformat__ = "restructuredtext en"
+
−
+
−import sys
+
−import os
+
−from os.path import join, exists
+
−from datetime import datetime
+
−
+
−from logilab.common.deprecation import deprecated
+
−from logilab.common.decorators import cached, clear_cache
+
−from logilab.common.adbh import get_adv_func_helper
+
−
+
−from yams.constraints import SizeConstraint
+
−from yams.schema2sql import eschema2sql, rschema2sql
+
−
+
−from cubicweb import AuthenticationError, ETYPE_NAME_MAP
+
−from cubicweb.schema import META_RTYPES, VIRTUAL_RTYPES, CubicWebRelationSchema
+
−from cubicweb.dbapi import get_repository, repo_connect
+
−from cubicweb.common.migration import MigrationHelper, yes
+
−
+
−try:
+
−    from cubicweb.server import SOURCE_TYPES, schemaserial as ss
+
−    from cubicweb.server.utils import manager_userpasswd, ask_source_config
+
−    from cubicweb.server.sqlutils import sqlexec, SQL_PREFIX
+
−except ImportError: # LAX
+
−    pass
+
−
+
−
+
−class ServerMigrationHelper(MigrationHelper):
+
−    """specific migration helper for server side  migration scripts,
+
−    providind actions related to schema/data migration
+
−    """
+
−
+
−    def __init__(self, config, schema, interactive=True,
+
−                 repo=None, cnx=None, verbosity=1, connect=True):
+
−        MigrationHelper.__init__(self, config, interactive, verbosity)
+
−        if not interactive:
+
−            assert cnx
+
−            assert repo
+
−        if cnx is not None:
+
−            assert repo
+
−            self._cnx = cnx
+
−            self.repo = repo
+
−        elif connect:
+
−            self.repo_connect()
+
−        if not schema:
+
−            schema = config.load_schema(expand_cubes=True)
+
−        self.fs_schema = schema
+
−        self._synchronized = set()
+
−
+
−    # overriden from base MigrationHelper ######################################
+
−
+
−    @cached
+
−    def repo_connect(self):
+
−        self.repo = get_repository(method='inmemory', config=self.config)
+
−        return self.repo
+
−
+
−    def cube_upgraded(self, cube, version):
+
−        self.cmd_set_property('system.version.%s' % cube.lower(),
+
−                              unicode(version))
+
−        self.commit()
+
−
+
−    def shutdown(self):
+
−        if self.repo is not None:
+
−            self.repo.shutdown()
+
−
+
−    def migrate(self, vcconf, toupgrade, options):
+
−        if not options.fs_only:
+
−            if options.backup_db is None:
+
−                self.backup_database()
+
−            elif options.backup_db:
+
−                self.backup_database(askconfirm=False)
+
−        super(ServerMigrationHelper, self).migrate(vcconf, toupgrade, options)
+
−
+
−    def process_script(self, migrscript, funcname=None, *args, **kwargs):
+
−        """execute a migration script
+
−        in interactive mode,  display the migration script path, ask for
+
−        confirmation and execute it if confirmed
+
−        """
+
−        try:
+
−            if migrscript.endswith('.sql'):
+
−                if self.execscript_confirm(migrscript):
+
−                    sqlexec(open(migrscript).read(), self.session.system_sql)
+
−            else:
+
−                return super(ServerMigrationHelper, self).process_script(
+
−                    migrscript, funcname, *args, **kwargs)
+
−            self.commit()
+
−        except:
+
−            self.rollback()
+
−            raise
+
−
+
−    # server specific migration methods ########################################
+
−
+
−    def backup_database(self, backupfile=None, askconfirm=True):
+
−        config = self.config
+
−        repo = self.repo_connect()
+
−        timestamp = datetime.now().strftime('%Y-%m-%d_%H:%M:%S')
+
−        for source in repo.sources:
+
−            source.backup(self.confirm, backupfile, timestamp,
+
−                          askconfirm=askconfirm)
+
−        repo.hm.call_hooks('server_backup', repo=repo, timestamp=timestamp)
+
−
+
−    def restore_database(self, backupfile, drop=True, systemonly=True,
+
−                         askconfirm=True):
+
−        config = self.config
+
−        repo = self.repo_connect()
+
−        if systemonly:
+
−            repo.system_source.restore(self.confirm, backupfile=backupfile,
+
−                                       drop=drop, askconfirm=askconfirm)
+
−        else:
+
−            # in that case, backup file is expected to be a time stamp
+
−            for source in repo.sources:
+
−                source.backup(self.confirm, timestamp=backupfile, drop=drop,
+
−                              askconfirm=askconfirm)
+
−            repo.hm.call_hooks('server_restore', repo=repo, timestamp=backupfile)
+
−
+
−    @property
+
−    def cnx(self):
+
−        """lazy connection"""
+
−        try:
+
−            return self._cnx
+
−        except AttributeError:
+
−            sourcescfg = self.repo.config.sources()
+
−            try:
+
−                login = sourcescfg['admin']['login']
+
−                pwd = sourcescfg['admin']['password']
+
−            except KeyError:
+
−                login, pwd = manager_userpasswd()
+
−            while True:
+
−                try:
+
−                    self._cnx = repo_connect(self.repo, login, pwd)
+
−                    if not 'managers' in self._cnx.user(self.session).groups:
+
−                        print 'migration need an account in the managers group'
+
−                    else:
+
−                        break
+
−                except AuthenticationError:
+
−                    print 'wrong user/password'
+
−                except (KeyboardInterrupt, EOFError):
+
−                    print 'aborting...'
+
−                    sys.exit(0)
+
−                try:
+
−                    login, pwd = manager_userpasswd()
+
−                except (KeyboardInterrupt, EOFError):
+
−                    print 'aborting...'
+
−                    sys.exit(0)
+
−            self.session.keep_pool_mode('transaction')
+
−            return self._cnx
+
−
+
−    @property
+
−    def session(self):
+
−        return self.repo._get_session(self.cnx.sessionid)
+
−
+
−    @property
+
−    @cached
+
−    def rqlcursor(self):
+
−        """lazy rql cursor"""
+
−        # should not give session as cnx.cursor(), else we may try to execute
+
−        # some query while no pool is set on the session (eg on entity attribute
+
−        # access for instance)
+
−        return self.cnx.cursor()
+
−
+
−    def commit(self):
+
−        if hasattr(self, '_cnx'):
+
−            self._cnx.commit()
+
−
+
−    def rollback(self):
+
−        if hasattr(self, '_cnx'):
+
−            self._cnx.rollback()
+
−
+
−    def rqlexecall(self, rqliter, cachekey=None, ask_confirm=True):
+
−        for rql, kwargs in rqliter:
+
−            self.rqlexec(rql, kwargs, cachekey, ask_confirm)
+
−
+
−    @cached
+
−    def _create_context(self):
+
−        """return a dictionary to use as migration script execution context"""
+
−        context = super(ServerMigrationHelper, self)._create_context()
+
−        context.update({'checkpoint': self.checkpoint,
+
−                        'sql': self.sqlexec,
+
−                        'rql': self.rqlexec,
+
−                        'rqliter': self.rqliter,
+
−                        'schema': self.repo.schema,
+
−                        'fsschema': self.fs_schema,
+
−                        'session' : self.session,
+
−                        'repo' : self.repo,
+
−                        'synchronize_schema': deprecated()(self.cmd_sync_schema_props_perms),
+
−                        'synchronize_eschema': deprecated()(self.cmd_sync_schema_props_perms),
+
−                        'synchronize_rschema': deprecated()(self.cmd_sync_schema_props_perms),
+
−                        })
+
−        return context
+
−
+
−    @cached
+
−    def group_mapping(self):
+
−        """cached group mapping"""
+
−        return ss.group_mapping(self.rqlcursor)
+
−
+
−    def exec_event_script(self, event, cubepath=None, funcname=None,
+
−                          *args, **kwargs):
+
−        if cubepath:
+
−            apc = join(cubepath, 'migration', '%s.py' % event)
+
−        else:
+
−            apc = join(self.config.migration_scripts_dir(), '%s.py' % event)
+
−        if exists(apc):
+
−            if self.config.free_wheel:
+
−                from cubicweb.server.hooks import setowner_after_add_entity
+
−                self.repo.hm.unregister_hook(setowner_after_add_entity,
+
−                                             'after_add_entity', '')
+
−                self.deactivate_verification_hooks()
+
−            self.info('executing %s', apc)
+
−            confirm = self.confirm
+
−            execscript_confirm = self.execscript_confirm
+
−            self.confirm = yes
+
−            self.execscript_confirm = yes
+
−            try:
+
−                return self.process_script(apc, funcname, *args, **kwargs)
+
−            finally:
+
−                self.confirm = confirm
+
−                self.execscript_confirm = execscript_confirm
+
−                if self.config.free_wheel:
+
−                    self.repo.hm.register_hook(setowner_after_add_entity,
+
−                                               'after_add_entity', '')
+
−                    self.reactivate_verification_hooks()
+
−
+
−    # schema synchronization internals ########################################
+
−
+
−    def _synchronize_permissions(self, ertype):
+
−        """permission synchronization for an entity or relation type"""
+
−        if ertype in VIRTUAL_RTYPES:
+
−            return
+
−        newrschema = self.fs_schema[ertype]
+
−        teid = self.repo.schema[ertype].eid
+
−        if 'update' in newrschema.ACTIONS or newrschema.is_final():
+
−            # entity type
+
−            exprtype = u'ERQLExpression'
+
−        else:
+
−            # relation type
+
−            exprtype = u'RRQLExpression'
+
−        assert teid, ertype
+
−        gm = self.group_mapping()
+
−        confirm = self.verbosity >= 2
+
−        # * remove possibly deprecated permission (eg in the persistent schema
+
−        #   but not in the new schema)
+
−        # * synchronize existing expressions
+
−        # * add new groups/expressions
+
−        for action in newrschema.ACTIONS:
+
−            perm = '%s_permission' % action
+
−            # handle groups
+
−            newgroups = list(newrschema.get_groups(action))
+
−            for geid, gname in self.rqlexec('Any G, GN WHERE T %s G, G name GN, '
+
−                                            'T eid %%(x)s' % perm, {'x': teid}, 'x',
+
−                                            ask_confirm=False):
+
−                if not gname in newgroups:
+
−                    if not confirm or self.confirm('remove %s permission of %s to %s?'
+
−                                                   % (action, ertype, gname)):
+
−                        self.rqlexec('DELETE T %s G WHERE G eid %%(x)s, T eid %s'
+
−                                     % (perm, teid),
+
−                                     {'x': geid}, 'x', ask_confirm=False)
+
−                else:
+
−                    newgroups.remove(gname)
+
−            for gname in newgroups:
+
−                if not confirm or self.confirm('grant %s permission of %s to %s?'
+
−                                               % (action, ertype, gname)):
+
−                    self.rqlexec('SET T %s G WHERE G eid %%(x)s, T eid %s'
+
−                                 % (perm, teid),
+
−                                 {'x': gm[gname]}, 'x', ask_confirm=False)
+
−            # handle rql expressions
+
−            newexprs = dict((expr.expression, expr) for expr in newrschema.get_rqlexprs(action))
+
−            for expreid, expression in self.rqlexec('Any E, EX WHERE T %s E, E expression EX, '
+
−                                                    'T eid %s' % (perm, teid),
+
−                                                    ask_confirm=False):
+
−                if not expression in newexprs:
+
−                    if not confirm or self.confirm('remove %s expression for %s permission of %s?'
+
−                                                   % (expression, action, ertype)):
+
−                        # deleting the relation will delete the expression entity
+
−                        self.rqlexec('DELETE T %s E WHERE E eid %%(x)s, T eid %s'
+
−                                     % (perm, teid),
+
−                                     {'x': expreid}, 'x', ask_confirm=False)
+
−                else:
+
−                    newexprs.pop(expression)
+
−            for expression in newexprs.values():
+
−                expr = expression.expression
+
−                if not confirm or self.confirm('add %s expression for %s permission of %s?'
+
−                                               % (expr, action, ertype)):
+
−                    self.rqlexec('INSERT RQLExpression X: X exprtype %%(exprtype)s, '
+
−                                 'X expression %%(expr)s, X mainvars %%(vars)s, T %s X '
+
−                                 'WHERE T eid %%(x)s' % perm,
+
−                                 {'expr': expr, 'exprtype': exprtype,
+
−                                  'vars': expression.mainvars, 'x': teid}, 'x',
+
−                                 ask_confirm=False)
+
−
+
−    def _synchronize_rschema(self, rtype, syncrdefs=True, syncperms=True):
+
−        """synchronize properties of the persistent relation schema against its
+
−        current definition:
+
−
+
−        * description
+
−        * symetric, meta
+
−        * inlined
+
−        * relation definitions if `syncrdefs`
+
−        * permissions if `syncperms`
+
−
+
−        physical schema changes should be handled by repository's schema hooks
+
−        """
+
−        rtype = str(rtype)
+
−        if rtype in self._synchronized:
+
−            return
+
−        self._synchronized.add(rtype)
+
−        rschema = self.fs_schema.rschema(rtype)
+
−        self.rqlexecall(ss.updaterschema2rql(rschema),
+
−                        ask_confirm=self.verbosity>=2)
+
−        reporschema = self.repo.schema.rschema(rtype)
+
−        if syncrdefs:
+
−            for subj, obj in rschema.iter_rdefs():
+
−                if not reporschema.has_rdef(subj, obj):
+
−                    continue
+
−                self._synchronize_rdef_schema(subj, rschema, obj)
+
−        if syncperms:
+
−            self._synchronize_permissions(rtype)
+
−
+
−    def _synchronize_eschema(self, etype, syncperms=True):
+
−        """synchronize properties of the persistent entity schema against
+
−        its current definition:
+
−
+
−        * description
+
−        * internationalizable, fulltextindexed, indexed, meta
+
−        * relations from/to this entity
+
−        * permissions if `syncperms`
+
−        """
+
−        etype = str(etype)
+
−        if etype in self._synchronized:
+
−            return
+
−        self._synchronized.add(etype)
+
−        repoeschema = self.repo.schema.eschema(etype)
+
−        try:
+
−            eschema = self.fs_schema.eschema(etype)
+
−        except KeyError:
+
−            return
+
−        repospschema = repoeschema.specializes()
+
−        espschema = eschema.specializes()
+
−        if repospschema and not espschema:
+
−            self.rqlexec('DELETE X specializes Y WHERE X is CWEType, X name %(x)s',
+
−                         {'x': str(repoeschema)})
+
−        elif not repospschema and espschema:
+
−            self.rqlexec('SET X specializes Y WHERE X is CWEType, X name %(x)s, '
+
−                         'Y is CWEType, Y name %(y)s',
+
−                         {'x': str(repoeschema), 'y': str(espschema)})
+
−        self.rqlexecall(ss.updateeschema2rql(eschema),
+
−                        ask_confirm=self.verbosity >= 2)
+
−        for rschema, targettypes, x in eschema.relation_definitions(True):
+
−            if x == 'subject':
+
−                if not rschema in repoeschema.subject_relations():
+
−                    continue
+
−                subjtypes, objtypes = [etype], targettypes
+
−            else: # x == 'object'
+
−                if not rschema in repoeschema.object_relations():
+
−                    continue
+
−                subjtypes, objtypes = targettypes, [etype]
+
−            self._synchronize_rschema(rschema, syncperms=syncperms,
+
−                                      syncrdefs=False)
+
−            reporschema = self.repo.schema.rschema(rschema)
+
−            for subj in subjtypes:
+
−                for obj in objtypes:
+
−                    if not reporschema.has_rdef(subj, obj):
+
−                        continue
+
−                    self._synchronize_rdef_schema(subj, rschema, obj)
+
−        if syncperms:
+
−            self._synchronize_permissions(etype)
+
−
+
−    def _synchronize_rdef_schema(self, subjtype, rtype, objtype):
+
−        """synchronize properties of the persistent relation definition schema
+
−        against its current definition:
+
−        * order and other properties
+
−        * constraints
+
−        """
+
−        subjtype, objtype = str(subjtype), str(objtype)
+
−        rschema = self.fs_schema.rschema(rtype)
+
−        reporschema = self.repo.schema.rschema(rschema)
+
−        if (subjtype, rschema, objtype) in self._synchronized:
+
−            return
+
−        self._synchronized.add((subjtype, rschema, objtype))
+
−        if rschema.symetric:
+
−            self._synchronized.add((objtype, rschema, subjtype))
+
−        confirm = self.verbosity >= 2
+
−        # properties
+
−        self.rqlexecall(ss.updaterdef2rql(rschema, subjtype, objtype),
+
−                        ask_confirm=confirm)
+
−        # constraints
+
−        newconstraints = list(rschema.rproperty(subjtype, objtype, 'constraints'))
+
−        # 1. remove old constraints and update constraints of the same type
+
−        # NOTE: don't use rschema.constraint_by_type because it may be
+
−        #       out of sync with newconstraints when multiple
+
−        #       constraints of the same type are used
+
−        for cstr in reporschema.rproperty(subjtype, objtype, 'constraints'):
+
−            for newcstr in newconstraints:
+
−                if newcstr.type() == cstr.type():
+
−                    break
+
−            else:
+
−                newcstr = None
+
−            if newcstr is None:
+
−                self.rqlexec('DELETE X constrained_by C WHERE C eid %(x)s',
+
−                             {'x': cstr.eid}, 'x',
+
−                             ask_confirm=confirm)
+
−                self.rqlexec('DELETE CWConstraint C WHERE C eid %(x)s',
+
−                             {'x': cstr.eid}, 'x',
+
−                             ask_confirm=confirm)
+
−            else:
+
−                newconstraints.remove(newcstr)
+
−                values = {'x': cstr.eid,
+
−                          'v': unicode(newcstr.serialize())}
+
−                self.rqlexec('SET X value %(v)s WHERE X eid %(x)s',
+
−                             values, 'x', ask_confirm=confirm)
+
−        # 2. add new constraints
+
−        for newcstr in newconstraints:
+
−            self.rqlexecall(ss.constraint2rql(rschema, subjtype, objtype,
+
−                                              newcstr),
+
−                            ask_confirm=confirm)
+
−
+
−    # base actions ############################################################
+
−
+
−    def checkpoint(self):
+
−        """checkpoint action"""
+
−        if self.confirm('commit now ?', shell=False):
+
−            self.commit()
+
−
+
−    def cmd_add_cube(self, cube, update_database=True):
+
−        self.cmd_add_cubes( (cube,), update_database)
+
−
+
−    def cmd_add_cubes(self, cubes, update_database=True):
+
−        """update_database is telling if the database schema should be updated
+
−        or if only the relevant eproperty should be inserted (for the case where
+
−        a cube has been extracted from an existing instance, so the
+
−        cube schema is already in there)
+
−        """
+
−        newcubes = super(ServerMigrationHelper, self).cmd_add_cubes(cubes)
+
−        if not newcubes:
+
−            return
+
−        for cube in newcubes:
+
−            self.cmd_set_property('system.version.'+cube,
+
−                                  self.config.cube_version(cube))
+
−            if cube in SOURCE_TYPES:
+
−                # don't use config.sources() in case some sources have been
+
−                # disabled for migration
+
−                sourcescfg = self.config.read_sources_file()
+
−                sourcescfg[cube] = ask_source_config(cube)
+
−                self.config.write_sources_file(sourcescfg)
+
−                clear_cache(self.config, 'read_sources_file')
+
−        if not update_database:
+
−            self.commit()
+
−            return
+
−        newcubes_schema = self.config.load_schema(construction_mode='non-strict')
+
−        new = set()
+
−        # execute pre-create files
+
−        for pack in reversed(newcubes):
+
−            self.exec_event_script('precreate', self.config.cube_dir(pack))
+
−        # add new entity and relation types
+
−        for rschema in newcubes_schema.relations():
+
−            if not rschema in self.repo.schema:
+
−                self.cmd_add_relation_type(rschema.type)
+
−                new.add(rschema.type)
+
−        for eschema in newcubes_schema.entities():
+
−            if not eschema in self.repo.schema:
+
−                self.cmd_add_entity_type(eschema.type)
+
−                new.add(eschema.type)
+
−        # check if attributes has been added to existing entities
+
−        for rschema in newcubes_schema.relations():
+
−            existingschema = self.repo.schema.rschema(rschema.type)
+
−            for (fromtype, totype) in rschema.iter_rdefs():
+
−                if existingschema.has_rdef(fromtype, totype):
+
−                    continue
+
−                # check we should actually add the relation definition
+
−                if not (fromtype in new or totype in new or rschema in new):
+
−                    continue
+
−                self.cmd_add_relation_definition(str(fromtype), rschema.type,
+
−                                                 str(totype))
+
−        # execute post-create files
+
−        for pack in reversed(newcubes):
+
−            self.exec_event_script('postcreate', self.config.cube_dir(pack))
+
−            self.commit()
+
−
+
−    def cmd_remove_cube(self, cube, removedeps=False):
+
−        removedcubes = super(ServerMigrationHelper, self).cmd_remove_cube(
+
−            cube, removedeps)
+
−        if not removedcubes:
+
−            return
+
−        fsschema = self.fs_schema
+
−        removedcubes_schema = self.config.load_schema(construction_mode='non-strict')
+
−        reposchema = self.repo.schema
+
−        # execute pre-remove files
+
−        for pack in reversed(removedcubes):
+
−            self.exec_event_script('preremove', self.config.cube_dir(pack))
+
−        # remove cubes'entity and relation types
+
−        for rschema in fsschema.relations():
+
−            if not rschema in removedcubes_schema and rschema in reposchema:
+
−                self.cmd_drop_relation_type(rschema.type)
+
−        for eschema in fsschema.entities():
+
−            if not eschema in removedcubes_schema and eschema in reposchema:
+
−                self.cmd_drop_entity_type(eschema.type)
+
−        for rschema in fsschema.relations():
+
−            if rschema in removedcubes_schema and rschema in reposchema:
+
−                # check if attributes/relations has been added to entities from
+
−                # other cubes
+
−                for fromtype, totype in rschema.iter_rdefs():
+
−                    if not removedcubes_schema[rschema.type].has_rdef(fromtype, totype) and \
+
−                           reposchema[rschema.type].has_rdef(fromtype, totype):
+
−                        self.cmd_drop_relation_definition(
+
−                            str(fromtype), rschema.type, str(totype))
+
−        # execute post-remove files
+
−        for pack in reversed(removedcubes):
+
−            self.exec_event_script('postremove', self.config.cube_dir(pack))
+
−            self.rqlexec('DELETE CWProperty X WHERE X pkey %(pk)s',
+
−                         {'pk': u'system.version.'+pack}, ask_confirm=False)
+
−            self.commit()
+
−
+
−    # schema migration actions ################################################
+
−
+
−    def cmd_add_attribute(self, etype, attrname, attrtype=None, commit=True):
+
−        """add a new attribute on the given entity type"""
+
−        if attrtype is None:
+
−            rschema = self.fs_schema.rschema(attrname)
+
−            attrtype = rschema.objects(etype)[0]
+
−        self.cmd_add_relation_definition(etype, attrname, attrtype, commit=commit)
+
−
+
−    def cmd_drop_attribute(self, etype, attrname, commit=True):
+
−        """drop an existing attribute from the given entity type
+
−
+
−        `attrname` is a string giving the name of the attribute to drop
+
−        """
+
−        rschema = self.repo.schema.rschema(attrname)
+
−        attrtype = rschema.objects(etype)[0]
+
−        self.cmd_drop_relation_definition(etype, attrname, attrtype, commit=commit)
+
−
+
−    def cmd_rename_attribute(self, etype, oldname, newname, commit=True):
+
−        """rename an existing attribute of the given entity type
+
−
+
−        `oldname` is a string giving the name of the existing attribute
+
−        `newname` is a string giving the name of the renamed attribute
+
−        """
+
−        eschema = self.fs_schema.eschema(etype)
+
−        attrtype = eschema.destination(newname)
+
−        # have to commit this first step anyway to get the definition
+
−        # actually in the schema
+
−        self.cmd_add_attribute(etype, newname, attrtype, commit=True)
+
−        # skipp NULL values if the attribute is required
+
−        rql = 'SET X %s VAL WHERE X is %s, X %s VAL' % (newname, etype, oldname)
+
−        card = eschema.rproperty(newname, 'cardinality')[0]
+
−        if card == '1':
+
−            rql += ', NOT X %s NULL' % oldname
+
−        self.rqlexec(rql, ask_confirm=self.verbosity>=2)
+
−        self.cmd_drop_attribute(etype, oldname, commit=commit)
+
−
+
−    def cmd_add_entity_type(self, etype, auto=True, commit=True):
+
−        """register a new entity type
+
−
+
−        in auto mode, automatically register entity's relation where the
+
−        targeted type is known
+
−        """
+
−        applschema = self.repo.schema
+
−        if etype in applschema:
+
−            eschema = applschema[etype]
+
−            if eschema.is_final():
+
−                applschema.del_entity_type(etype)
+
−        else:
+
−            eschema = self.fs_schema.eschema(etype)
+
−        confirm = self.verbosity >= 2
+
−        # register the entity into CWEType
+
−        self.rqlexecall(ss.eschema2rql(eschema), ask_confirm=confirm)
+
−        # add specializes relation if needed
+
−        self.rqlexecall(ss.eschemaspecialize2rql(eschema), ask_confirm=confirm)
+
−        # register groups / permissions for the entity
+
−        self.rqlexecall(ss.erperms2rql(eschema, self.group_mapping()),
+
−                        ask_confirm=confirm)
+
−        # register entity's attributes
+
−        for rschema, attrschema in eschema.attribute_definitions():
+
−            # ignore those meta relations, they will be automatically added
+
−            if rschema.type in META_RTYPES:
+
−                continue
+
−            if not rschema.type in applschema:
+
−                # need to add the relation type and to commit to get it
+
−                # actually in the schema
+
−                self.cmd_add_relation_type(rschema.type, False, commit=True)
+
−            # register relation definition
+
−            self.rqlexecall(ss.rdef2rql(rschema, etype, attrschema.type),
+
−                            ask_confirm=confirm)
+
−        if auto:
+
−            # we have commit here to get relation types actually in the schema
+
−            self.commit()
+
−            added = []
+
−            for rschema in eschema.subject_relations():
+
−                # attribute relation have already been processed and
+
−                # 'owned_by'/'created_by' will be automatically added
+
−                if rschema.final or rschema.type in META_RTYPES:
+
−                    continue
+
−                rtypeadded = rschema.type in applschema
+
−                for targetschema in rschema.objects(etype):
+
−                    # ignore relations where the targeted type is not in the
+
−                    # current instance schema
+
−                    targettype = targetschema.type
+
−                    if not targettype in applschema and targettype != etype:
+
−                        continue
+
−                    if not rtypeadded:
+
−                        # need to add the relation type and to commit to get it
+
−                        # actually in the schema
+
−                        added.append(rschema.type)
+
−                        self.cmd_add_relation_type(rschema.type, False, commit=True)
+
−                        rtypeadded = True
+
−                    # register relation definition
+
−                    # remember this two avoid adding twice non symetric relation
+
−                    # such as "Emailthread forked_from Emailthread"
+
−                    added.append((etype, rschema.type, targettype))
+
−                    self.rqlexecall(ss.rdef2rql(rschema, etype, targettype),
+
−                                    ask_confirm=confirm)
+
−            for rschema in eschema.object_relations():
+
−                rtypeadded = rschema.type in applschema or rschema.type in added
+
−                for targetschema in rschema.subjects(etype):
+
−                    # ignore relations where the targeted type is not in the
+
−                    # current instance schema
+
−                    targettype = targetschema.type
+
−                    # don't check targettype != etype since in this case the
+
−                    # relation has already been added as a subject relation
+
−                    if not targettype in applschema:
+
−                        continue
+
−                    if not rtypeadded:
+
−                        # need to add the relation type and to commit to get it
+
−                        # actually in the schema
+
−                        self.cmd_add_relation_type(rschema.type, False, commit=True)
+
−                        rtypeadded = True
+
−                    elif (targettype, rschema.type, etype) in added:
+
−                        continue
+
−                    # register relation definition
+
−                    self.rqlexecall(ss.rdef2rql(rschema, targettype, etype),
+
−                                    ask_confirm=confirm)
+
−        if commit:
+
−            self.commit()
+
−
+
−    def cmd_drop_entity_type(self, etype, commit=True):
+
−        """unregister an existing entity type
+
−
+
−        This will trigger deletion of necessary relation types and definitions
+
−        """
+
−        # XXX what if we delete an entity type which is specialized by other types
+
−        # unregister the entity from CWEType
+
−        self.rqlexec('DELETE CWEType X WHERE X name %(etype)s', {'etype': etype},
+
−                     ask_confirm=self.verbosity>=2)
+
−        if commit:
+
−            self.commit()
+
−
+
−    def cmd_rename_entity_type(self, oldname, newname, commit=True):
+
−        """rename an existing entity type in the persistent schema
+
−
+
−        `oldname` is a string giving the name of the existing entity type
+
−        `newname` is a string giving the name of the renamed entity type
+
−        """
+
−        self.rqlexec('SET ET name %(newname)s WHERE ET is CWEType, ET name %(oldname)s',
+
−                     {'newname' : unicode(newname), 'oldname' : oldname},
+
−                     ask_confirm=False)
+
−        if commit:
+
−            self.commit()
+
−
+
−    def cmd_add_relation_type(self, rtype, addrdef=True, commit=True):
+
−        """register a new relation type named `rtype`, as described in the
+
−        schema description file.
+
−
+
−        `addrdef` is a boolean value; when True, it will also add all relations
+
−        of the type just added found in the schema definition file. Note that it
+
−        implies an intermediate "commit" which commits the relation type
+
−        creation (but not the relation definitions themselves, for which
+
−        committing depends on the `commit` argument value).
+
−
+
−        """
+
−        rschema = self.fs_schema.rschema(rtype)
+
−        # register the relation into CWRType and insert necessary relation
+
−        # definitions
+
−        self.rqlexecall(ss.rschema2rql(rschema, addrdef=False),
+
−                        ask_confirm=self.verbosity>=2)
+
−        # register groups / permissions for the relation
+
−        self.rqlexecall(ss.erperms2rql(rschema, self.group_mapping()),
+
−                        ask_confirm=self.verbosity>=2)
+
−        if addrdef:
+
−            self.commit()
+
−            self.rqlexecall(ss.rdef2rql(rschema),
+
−                            ask_confirm=self.verbosity>=2)
+
−        if commit:
+
−            self.commit()
+
−
+
−    def cmd_drop_relation_type(self, rtype, commit=True):
+
−        """unregister an existing relation type"""
+
−        # unregister the relation from CWRType
+
−        self.rqlexec('DELETE CWRType X WHERE X name %r' % rtype,
+
−                     ask_confirm=self.verbosity>=2)
+
−        if commit:
+
−            self.commit()
+
−
+
−    def cmd_rename_relation(self, oldname, newname, commit=True):
+
−        """rename an existing relation
+
−
+
−        `oldname` is a string giving the name of the existing relation
+
−        `newname` is a string giving the name of the renamed relation
+
−        """
+
−        self.cmd_add_relation_type(newname, commit=True)
+
−        self.rqlexec('SET X %s Y WHERE X %s Y' % (newname, oldname),
+
−                     ask_confirm=self.verbosity>=2)
+
−        self.cmd_drop_relation_type(oldname, commit=commit)
+
−
+
−    def cmd_add_relation_definition(self, subjtype, rtype, objtype, commit=True):
+
−        """register a new relation definition, from its definition found in the
+
−        schema definition file
+
−        """
+
−        rschema = self.fs_schema.rschema(rtype)
+
−        if not rtype in self.repo.schema:
+
−            self.cmd_add_relation_type(rtype, addrdef=False, commit=True)
+
−        self.rqlexecall(ss.rdef2rql(rschema, subjtype, objtype),
+
−                        ask_confirm=self.verbosity>=2)
+
−        if commit:
+
−            self.commit()
+
−
+
−    def cmd_drop_relation_definition(self, subjtype, rtype, objtype, commit=True):
+
−        """unregister an existing relation definition"""
+
−        rschema = self.repo.schema.rschema(rtype)
+
−        # unregister the definition from CWAttribute or CWRelation
+
−        if rschema.is_final():
+
−            etype = 'CWAttribute'
+
−        else:
+
−            etype = 'CWRelation'
+
−        rql = ('DELETE %s X WHERE X from_entity FE, FE name "%s",'
+
−               'X relation_type RT, RT name "%s", X to_entity TE, TE name "%s"')
+
−        self.rqlexec(rql % (etype, subjtype, rtype, objtype),
+
−                     ask_confirm=self.verbosity>=2)
+
−        if commit:
+
−            self.commit()
+
−
+
−    def cmd_sync_schema_props_perms(self, ertype=None, syncperms=True,
+
−                                    syncprops=True, syncrdefs=True, commit=True):
+
−        """synchronize the persistent schema against the current definition
+
−        schema.
+
−
+
−        It will synch common stuff between the definition schema and the
+
−        actual persistent schema, it won't add/remove any entity or relation.
+
−        """
+
−        assert syncperms or syncprops, 'nothing to do'
+
−        if ertype is not None:
+
−            if isinstance(ertype, (tuple, list)):
+
−                assert len(ertype) == 3, 'not a relation definition'
+
−                assert syncprops, 'can\'t update permission for a relation definition'
+
−                self._synchronize_rdef_schema(*ertype)
+
−            elif syncprops:
+
−                erschema = self.repo.schema[ertype]
+
−                if isinstance(erschema, CubicWebRelationSchema):
+
−                    self._synchronize_rschema(erschema, syncperms=syncperms,
+
−                                              syncrdefs=syncrdefs)
+
−                else:
+
−                    self._synchronize_eschema(erschema, syncperms=syncperms)
+
−            else:
+
−                self._synchronize_permissions(ertype)
+
−        else:
+
−            for etype in self.repo.schema.entities():
+
−                if syncprops:
+
−                    self._synchronize_eschema(etype, syncperms=syncperms)
+
−                else:
+
−                    self._synchronize_permissions(etype)
+
−        if commit:
+
−            self.commit()
+
−
+
−    def cmd_change_relation_props(self, subjtype, rtype, objtype,
+
−                                  commit=True, **kwargs):
+
−        """change some properties of a relation definition
+
−
+
−        you usually want to use sync_schema_props_perms instead.
+
−        """
+
−        assert kwargs
+
−        restriction = []
+
−        if subjtype and subjtype != 'Any':
+
−            restriction.append('X from_entity FE, FE name "%s"' % subjtype)
+
−        if objtype and objtype != 'Any':
+
−            restriction.append('X to_entity TE, TE name "%s"' % objtype)
+
−        if rtype and rtype != 'Any':
+
−            restriction.append('X relation_type RT, RT name "%s"' % rtype)
+
−        assert restriction
+
−        values = []
+
−        for k, v in kwargs.items():
+
−            values.append('X %s %%(%s)s' % (k, k))
+
−            if isinstance(v, str):
+
−                kwargs[k] = unicode(v)
+
−        rql = 'SET %s WHERE %s' % (','.join(values), ','.join(restriction))
+
−        self.rqlexec(rql, kwargs, ask_confirm=self.verbosity>=2)
+
−        if commit:
+
−            self.commit()
+
−
+
−    def cmd_set_size_constraint(self, etype, rtype, size, commit=True):
+
−        """set change size constraint of a string attribute
+
−
+
−        if size is None any size constraint will be removed.
+
−
+
−        you usually want to use sync_schema_props_perms instead.
+
−        """
+
−        oldvalue = None
+
−        for constr in self.repo.schema.eschema(etype).constraints(rtype):
+
−            if isinstance(constr, SizeConstraint):
+
−                oldvalue = constr.max
+
−        if oldvalue == size:
+
−            return
+
−        if oldvalue is None and not size is None:
+
−            ceid = self.rqlexec('INSERT CWConstraint C: C value %(v)s, C cstrtype CT '
+
−                                'WHERE CT name "SizeConstraint"',
+
−                                {'v': SizeConstraint(size).serialize()},
+
−                                ask_confirm=self.verbosity>=2)[0][0]
+
−            self.rqlexec('SET X constrained_by C WHERE X from_entity S, X relation_type R, '
+
−                         'S name "%s", R name "%s", C eid %s' % (etype, rtype, ceid),
+
−                         ask_confirm=self.verbosity>=2)
+
−        elif not oldvalue is None:
+
−            if not size is None:
+
−                self.rqlexec('SET C value %%(v)s WHERE X from_entity S, X relation_type R,'
+
−                             'X constrained_by C, C cstrtype CT, CT name "SizeConstraint",'
+
−                             'S name "%s", R name "%s"' % (etype, rtype),
+
−                             {'v': unicode(SizeConstraint(size).serialize())},
+
−                             ask_confirm=self.verbosity>=2)
+
−            else:
+
−                self.rqlexec('DELETE X constrained_by C WHERE X from_entity S, X relation_type R,'
+
−                             'X constrained_by C, C cstrtype CT, CT name "SizeConstraint",'
+
−                             'S name "%s", R name "%s"' % (etype, rtype),
+
−                             ask_confirm=self.verbosity>=2)
+
−                # cleanup unused constraints
+
−                self.rqlexec('DELETE CWConstraint C WHERE NOT X constrained_by C')
+
−        if commit:
+
−            self.commit()
+
−
+
−    @deprecated('use sync_schema_props_perms(ertype, syncprops=False)')
+
−    def cmd_synchronize_permissions(self, ertype, commit=True):
+
−        self.cmd_sync_schema_props_perms(ertype, syncprops=False, commit=commit)
+
−
+
−    # Workflows handling ######################################################
+
−
+
−    def cmd_add_state(self, name, stateof, initial=False, commit=False, **kwargs):
+
−        """method to ease workflow definition: add a state for one or more
+
−        entity type(s)
+
−        """
+
−        stateeid = self.cmd_add_entity('State', name=name, **kwargs)
+
−        if not isinstance(stateof, (list, tuple)):
+
−            stateof = (stateof,)
+
−        for etype in stateof:
+
−            # XXX ensure etype validity
+
−            self.rqlexec('SET X state_of Y WHERE X eid %(x)s, Y name %(et)s',
+
−                         {'x': stateeid, 'et': etype}, 'x', ask_confirm=False)
+
−            if initial:
+
−                self.rqlexec('SET ET initial_state S WHERE ET name %(et)s, S eid %(x)s',
+
−                             {'x': stateeid, 'et': etype}, 'x', ask_confirm=False)
+
−        if commit:
+
−            self.commit()
+
−        return stateeid
+
−
+
−    def cmd_add_transition(self, name, transitionof, fromstates, tostate,
+
−                           requiredgroups=(), conditions=(), commit=False, **kwargs):
+
−        """method to ease workflow definition: add a transition for one or more
+
−        entity type(s), from one or more state and to a single state
+
−        """
+
−        treid = self.cmd_add_entity('Transition', name=name, **kwargs)
+
−        if not isinstance(transitionof, (list, tuple)):
+
−            transitionof = (transitionof,)
+
−        for etype in transitionof:
+
−            # XXX ensure etype validity
+
−            self.rqlexec('SET X transition_of Y WHERE X eid %(x)s, Y name %(et)s',
+
−                         {'x': treid, 'et': etype}, 'x', ask_confirm=False)
+
−        for stateeid in fromstates:
+
−            self.rqlexec('SET X allowed_transition Y WHERE X eid %(x)s, Y eid %(y)s',
+
−                         {'x': stateeid, 'y': treid}, 'x', ask_confirm=False)
+
−        self.rqlexec('SET X destination_state Y WHERE X eid %(x)s, Y eid %(y)s',
+
−                     {'x': treid, 'y': tostate}, 'x', ask_confirm=False)
+
−        self.cmd_set_transition_permissions(treid, requiredgroups, conditions,
+
−                                            reset=False)
+
−        if commit:
+
−            self.commit()
+
−        return treid
+
−
+
−    def cmd_set_transition_permissions(self, treid,
+
−                                       requiredgroups=(), conditions=(),
+
−                                       reset=True, commit=False):
+
−        """set or add (if `reset` is False) groups and conditions for a
+
−        transition
+
−        """
+
−        if reset:
+
−            self.rqlexec('DELETE T require_group G WHERE T eid %(x)s',
+
−                         {'x': treid}, 'x', ask_confirm=False)
+
−            self.rqlexec('DELETE T condition R WHERE T eid %(x)s',
+
−                         {'x': treid}, 'x', ask_confirm=False)
+
−        for gname in requiredgroups:
+
−            ### XXX ensure gname validity
+
−            self.rqlexec('SET T require_group G WHERE T eid %(x)s, G name %(gn)s',
+
−                         {'x': treid, 'gn': gname}, 'x', ask_confirm=False)
+
−        if isinstance(conditions, basestring):
+
−            conditions = (conditions,)
+
−        for expr in conditions:
+
−            if isinstance(expr, str):
+
−                expr = unicode(expr)
+
−            self.rqlexec('INSERT RQLExpression X: X exprtype "ERQLExpression", '
+
−                         'X expression %(expr)s, T condition X '
+
−                         'WHERE T eid %(x)s',
+
−                         {'x': treid, 'expr': expr}, 'x', ask_confirm=False)
+
−        if commit:
+
−            self.commit()
+
−
+
−    def cmd_set_state(self, eid, statename, commit=False):
+
−        self.session.set_pool() # ensure pool is set
+
−        entity = self.session.entity_from_eid(eid)
+
−        entity.change_state(entity.wf_state(statename).eid)
+
−        if commit:
+
−            self.commit()
+
−
+
−    # CWProperty handling ######################################################
+
−
+
−    def cmd_property_value(self, pkey):
+
−        rql = 'Any V WHERE X is CWProperty, X pkey %(k)s, X value V'
+
−        rset = self.rqlexec(rql, {'k': pkey}, ask_confirm=False)
+
−        return rset[0][0]
+
−
+
−    def cmd_set_property(self, pkey, value):
+
−        value = unicode(value)
+
−        try:
+
−            prop = self.rqlexec('CWProperty X WHERE X pkey %(k)s', {'k': pkey},
+
−                                ask_confirm=False).get_entity(0, 0)
+
−        except:
+
−            self.cmd_add_entity('CWProperty', pkey=unicode(pkey), value=value)
+
−        else:
+
−            self.rqlexec('SET X value %(v)s WHERE X pkey %(k)s',
+
−                         {'k': pkey, 'v': value}, ask_confirm=False)
+
−
+
−    # other data migration commands ###########################################
+
−
+
−    def cmd_add_entity(self, etype, *args, **kwargs):
+
−        """add a new entity of the given type"""
+
−        rql = 'INSERT %s X' % etype
+
−        relations = []
+
−        restrictions = []
+
−        for rtype, rvar in args:
+
−            relations.append('X %s %s' % (rtype, rvar))
+
−            restrictions.append('%s eid %s' % (rvar, kwargs.pop(rvar)))
+
−        commit = kwargs.pop('commit', False)
+
−        for attr in kwargs:
+
−            relations.append('X %s %%(%s)s' % (attr, attr))
+
−        if relations:
+
−            rql = '%s: %s' % (rql, ', '.join(relations))
+
−        if restrictions:
+
−            rql = '%s WHERE %s' % (rql, ', '.join(restrictions))
+
−        eid = self.rqlexec(rql, kwargs, ask_confirm=self.verbosity>=2).rows[0][0]
+
−        if commit:
+
−            self.commit()
+
−        return eid
+
−
+
−    def sqlexec(self, sql, args=None, ask_confirm=True):
+
−        """execute the given sql if confirmed
+
−
+
−        should only be used for low level stuff undoable with existing higher
+
−        level actions
+
−        """
+
−        if not ask_confirm or self.confirm('execute sql: %s ?' % sql):
+
−            self.session.set_pool() # ensure pool is set
+
−            try:
+
−                cu = self.session.system_sql(sql, args)
+
−            except:
+
−                ex = sys.exc_info()[1]
+
−                if self.confirm('error: %s\nabort?' % ex):
+
−                    raise
+
−                return
+
−            try:
+
−                return cu.fetchall()
+
−            except:
+
−                # no result to fetch
+
−                return
+
−
+
−    def rqlexec(self, rql, kwargs=None, cachekey=None, ask_confirm=True):
+
−        """rql action"""
+
−        if not isinstance(rql, (tuple, list)):
+
−            rql = ( (rql, kwargs), )
+
−        res = None
+
−        for rql, kwargs in rql:
+
−            if kwargs:
+
−                msg = '%s (%s)' % (rql, kwargs)
+
−            else:
+
−                msg = rql
+
−            if not ask_confirm or self.confirm('execute rql: %s ?' % msg):
+
−                try:
+
−                    res = self.rqlcursor.execute(rql, kwargs, cachekey)
+
−                except Exception, ex:
+
−                    if self.confirm('error: %s\nabort?' % ex):
+
−                        raise
+
−        return res
+
−
+
−    def rqliter(self, rql, kwargs=None, ask_confirm=True):
+
−        return ForRqlIterator(self, rql, None, ask_confirm)
+
−
+
−    def cmd_deactivate_verification_hooks(self):
+
−        self.repo.hm.deactivate_verification_hooks()
+
−
+
−    def cmd_reactivate_verification_hooks(self):
+
−        self.repo.hm.reactivate_verification_hooks()
+
−
+
−    # broken db commands ######################################################
+
−
+
−    def cmd_change_attribute_type(self, etype, attr, newtype, commit=True):
+
−        """low level method to change the type of an entity attribute. This is
+
−        a quick hack which has some drawback:
+
−        * only works when the old type can be changed to the new type by the
+
−          underlying rdbms (eg using ALTER TABLE)
+
−        * the actual schema won't be updated until next startup
+
−        """
+
−        rschema = self.repo.schema.rschema(attr)
+
−        oldtype = rschema.objects(etype)[0]
+
−        rdefeid = rschema.rproperty(etype, oldtype, 'eid')
+
−        sql = ("UPDATE CWAttribute "
+
−               "SET to_entity=(SELECT eid FROM CWEType WHERE name='%s')"
+
−               "WHERE eid=%s") % (newtype, rdefeid)
+
−        self.sqlexec(sql, ask_confirm=False)
+
−        dbhelper = self.repo.system_source.dbhelper
+
−        sqltype = dbhelper.TYPE_MAPPING[newtype]
+
−        sql = 'ALTER TABLE %s ALTER COLUMN %s TYPE %s' % (etype, attr, sqltype)
+
−        self.sqlexec(sql, ask_confirm=False)
+
−        if commit:
+
−            self.commit()
+
−
+
−    def cmd_add_entity_type_table(self, etype, commit=True):
+
−        """low level method to create the sql table for an existing entity.
+
−        This may be useful on accidental desync between the repository schema
+
−        and a sql database
+
−        """
+
−        dbhelper = self.repo.system_source.dbhelper
+
−        tablesql = eschema2sql(dbhelper, self.repo.schema.eschema(etype),
+
−                               prefix=SQL_PREFIX)
+
−        for sql in tablesql.split(';'):
+
−            if sql.strip():
+
−                self.sqlexec(sql)
+
−        if commit:
+
−            self.commit()
+
−
+
−    def cmd_add_relation_type_table(self, rtype, commit=True):
+
−        """low level method to create the sql table for an existing relation.
+
−        This may be useful on accidental desync between the repository schema
+
−        and a sql database
+
−        """
+
−        dbhelper = self.repo.system_source.dbhelper
+
−        tablesql = rschema2sql(dbhelper, self.repo.schema.rschema(rtype))
+
−        for sql in tablesql.split(';'):
+
−            if sql.strip():
+
−                self.sqlexec(sql)
+
−        if commit:
+
−            self.commit()
+
−
+
−
+
−class ForRqlIterator:
+
−    """specific rql iterator to make the loop skipable"""
+
−    def __init__(self, helper, rql, kwargs, ask_confirm):
+
−        self._h = helper
+
−        self.rql = rql
+
−        self.kwargs = kwargs
+
−        self.ask_confirm = ask_confirm
+
−        self._rsetit = None
+
−
+
−    def __iter__(self):
+
−        return self
+
−
+
−    def next(self):
+
−        if self._rsetit is not None:
+
−            return self._rsetit.next()
+
−        rql, kwargs = self.rql, self.kwargs
+
−        if kwargs:
+
−            msg = '%s (%s)' % (rql, kwargs)
+
−        else:
+
−            msg = rql
+
−        if self.ask_confirm:
+
−            if not self._h.confirm('execute rql: %s ?' % msg):
+
−                raise StopIteration
+
−        try:
+
−            rset = self._h.rqlcursor.execute(rql, kwargs)
+
−        except Exception, ex:
+
−            if self._h.confirm('error: %s\nabort?' % ex):
+
−                raise
+
−            else:
+
−                raise StopIteration
+
−        self._rsetit = iter(rset)
+
−        return self._rsetit.next()