cubicweb: comparison server/migractions.py

equal deleted inserted replaced

-:c25da7573ebd
+:02b52bf9f5f8
 from glob import glob
 from warnings import warn
 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 import AuthenticationError
 from cubicweb.schema import (META_RTYPES, VIRTUAL_RTYPES,
 CubicWebRelationSchema, order_eschemas)
 from cubicweb.dbapi import get_repository, repo_connect
-from cubicweb.common.migration import MigrationHelper, yes
+from cubicweb.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
 # backup
 tmpdir = tempfile.mkdtemp(dir=instbkdir)
 try:
 for source in repo.sources:
 try:
-source.backup(osp.join(tmpdir, source.uri))
+source.backup(osp.join(tmpdir, source.uri), self.confirm)
-except Exception, exc:
+except Exception, ex:
-print '-> error trying to backup [%s]' % exc
+print '-> error trying to backup %s [%s]' % (source.uri, ex)
 if not self.confirm('Continue anyway?', default='n'):
 raise SystemExit(1)
 else:
 break
 else:
 bkup = tarfile.open(backupfile, 'w|gz')
 for filename in os.listdir(tmpdir):
-bkup.add(osp.join(tmpdir,filename), filename)
+bkup.add(osp.join(tmpdir, filename), filename)
 bkup.close()
 # call hooks
 repo.hm.call_hooks('server_backup', repo=repo, timestamp=timestamp)
 # done
 print '-> backup file',  backupfile
 def restore_database(self, backupfile, drop=True, systemonly=True,
 askconfirm=True):
 # check
 if not osp.exists(backupfile):
 raise Exception("Backup file %s doesn't exist" % backupfile)
-return
 if askconfirm and not self.confirm('Restore %s database from %s ?'
 % (self.config.appid, backupfile)):
 return
 # unpack backup
 tmpdir = tempfile.mkdtemp()
 try:
 bkup = tarfile.open(backupfile, 'r|gz')
 except tarfile.ReadError:
 # assume restoring old backup
 shutil.copy(backupfile, osp.join(tmpdir, 'system'))
 else:
 for name in bkup.getnames():
 if name[0] in '/.':
 raise Exception('Security check failed, path starts with "/" or "."')
 bkup.close() # XXX seek error if not close+open !?!
 bkup = tarfile.open(backupfile, 'r|gz')
 bkup.extractall(path=tmpdir)
 bkup.close()
 self.config.open_connections_pools = False
 repo = self.repo_connect()
 for source in repo.sources:
 if systemonly and source.uri != 'system':
 continue
 try:
 source.restore(osp.join(tmpdir, source.uri), self.confirm, drop)
 except Exception, exc:
-print '-> error trying to restore [%s]' % exc
+print '-> error trying to restore %s [%s]' % (source.uri, exc)
 if not self.confirm('Continue anyway?', default='n'):
 raise SystemExit(1)
 shutil.rmtree(tmpdir)
 # call hooks
 repo.open_connections_pools()
 pwd = sourcescfg['admin']['password']
 except KeyError:
 login, pwd = manager_userpasswd()
 while True:
 try:
-self._cnx = repo_connect(self.repo, login, pwd)
+self._cnx = repo_connect(self.repo, login, password=pwd)
 if not 'managers' in self._cnx.user(self.session).groups:
 print 'migration need an account in the managers group'
 else:
 break
 except AuthenticationError:
 @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,
+context.update({'commit': self.checkpoint,
+'rollback': self.rollback,
+'checkpoint': deprecated('[3.6] use commit')(self.checkpoint),
 'sql': self.sqlexec,
 'rql': self.rqlexec,
 'rqliter': self.rqliter,
 'schema': self.repo.get_schema(),
 'cnx': self.cnx,
 'fsschema': self.fs_schema,
 'session' : self.session,
 'repo' : self.repo,
-'synchronize_schema': deprecated()(self.cmd_sync_schema_props_perms),
+'synchronize_schema': deprecated()(self.cmd_sync_schema_props_perms), # 3.4
-'synchronize_eschema': deprecated()(self.cmd_sync_schema_props_perms),
+'synchronize_eschema': deprecated()(self.cmd_sync_schema_props_perms), # 3.4
-'synchronize_rschema': deprecated()(self.cmd_sync_schema_props_perms),
+'synchronize_rschema': deprecated()(self.cmd_sync_schema_props_perms), # 3.4
 })
 return context
 @cached
 def group_mapping(self):
 apc = osp.join(cubepath, 'migration', '%s.py' % event)
 else:
 apc = osp.join(self.config.migration_scripts_dir(), '%s.py' % event)
 if osp.exists(apc):
 if self.config.free_wheel:
-from cubicweb.server.hooks import setowner_after_add_entity
+self.cmd_deactivate_verification_hooks()
-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
 return self.cmd_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,
+self.cmd_reactivate_verification_hooks()
-'after_add_entity', '')
-self.reactivate_verification_hooks()
 def install_custom_sql_scripts(self, directory, driver):
 self.session.set_pool() # ensure pool is set
 for fpath in glob(osp.join(directory, '*.sql.%s' % driver)):
 newname = osp.basename(fpath).replace('.sql.%s' % driver,
 sqlexec(open(fpath).read(), self.session.system_sql, False,
 delimiter=';;')
 # schema synchronization internals ########################################
-def _synchronize_permissions(self, ertype):
+def _synchronize_permissions(self, erschema, teid):
 """permission synchronization for an entity or relation type"""
-if ertype in VIRTUAL_RTYPES:
+assert teid, erschema
-return
+if 'update' in erschema.ACTIONS or erschema.final:
-newrschema = self.fs_schema[ertype]
-teid = self.repo.schema[ertype].eid
-if 'update' in newrschema.ACTIONS or newrschema.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:
+for action in erschema.ACTIONS:
 perm = '%s_permission' % action
 # handle groups
-newgroups = list(newrschema.get_groups(action))
+newgroups = list(erschema.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?'
+if not confirm or self.confirm('Remove %s permission of %s to %s?'
-% (action, ertype, gname)):
+% (action, erschema, 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?'
+if not confirm or self.confirm('Grant %s permission of %s to %s?'
-% (action, ertype, gname)):
+% (action, erschema, 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))
+newexprs = dict((expr.expression, expr) for expr in erschema.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?'
+if not confirm or self.confirm('Remove %s expression for %s permission of %s?'
-% (expression, action, ertype)):
+% (expression, action, erschema)):
 # 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?'
+if not confirm or self.confirm('Add %s expression for %s permission of %s?'
-% (expr, action, ertype)):
+% (expr, action, erschema)):
 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):
+def _synchronize_rschema(self, rtype, syncrdefs=True, syncperms=True, syncprops=True):
 """synchronize properties of the persistent relation schema against its
 current definition:
 * description
-* symetric, meta
+* symmetric, 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),
+if syncprops:
-ask_confirm=self.verbosity>=2)
+self.rqlexecall(ss.updaterschema2rql(rschema),
-reporschema = self.repo.schema.rschema(rtype)
+ask_confirm=self.verbosity>=2)
 if syncrdefs:
-for subj, obj in rschema.iter_rdefs():
+reporschema = self.repo.schema.rschema(rtype)
-if not reporschema.has_rdef(subj, obj):
+for subj, obj in rschema.rdefs:
+if (subj, obj) not in reporschema.rdefs:
 continue
-self._synchronize_rdef_schema(subj, rschema, obj)
+self._synchronize_rdef_schema(subj, rschema, obj,
-if syncperms:
+syncprops=syncprops,
-self._synchronize_permissions(rtype)
+syncperms=syncperms)
 def _synchronize_eschema(self, etype, syncperms=True):
 """synchronize properties of the persistent entity schema against
 its current definition:
 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):
+if (subj, obj) not in reporschema.rdefs:
 continue
 self._synchronize_rdef_schema(subj, rschema, obj)
 if syncperms:
-self._synchronize_permissions(etype)
+self._synchronize_permissions(eschema, repoeschema.eid)
-def _synchronize_rdef_schema(self, subjtype, rtype, objtype):
+def _synchronize_rdef_schema(self, subjtype, rtype, objtype,
+syncperms=True, syncprops=True):
 """synchronize properties of the persistent relation definition schema
 against its current definition:
 * order and other properties
 * constraints
 """
 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:
+if rschema.symmetric:
 self._synchronized.add((objtype, rschema, subjtype))
+rdef = rschema.rdef(subjtype, objtype)
+if rdef.infered:
+return # don't try to synchronize infered relation defs
+repordef = reporschema.rdef(subjtype, objtype)
 confirm = self.verbosity >= 2
-# properties
+if syncprops:
-self.rqlexecall(ss.updaterdef2rql(rschema, subjtype, objtype),
+# properties
-ask_confirm=confirm)
+self.rqlexecall(ss.updaterdef2rql(rschema, subjtype, objtype),
-# constraints
+ask_confirm=confirm)
-newconstraints = list(rschema.rproperty(subjtype, objtype, 'constraints'))
+# constraints
-# 1. remove old constraints and update constraints of the same type
+newconstraints = list(rdef.constraints)
-# NOTE: don't use rschema.constraint_by_type because it may be
+# 1. remove old constraints and update constraints of the same type
-#       out of sync with newconstraints when multiple
+# NOTE: don't use rschema.constraint_by_type because it may be
-#       constraints of the same type are used
+#       out of sync with newconstraints when multiple
-for cstr in reporschema.rproperty(subjtype, objtype, 'constraints'):
+#       constraints of the same type are used
+for cstr in repordef.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)
+else:
+newconstraints.remove(newcstr)
+value = unicode(newcstr.serialize())
+if value != unicode(cstr.serialize()):
+self.rqlexec('SET X value %(v)s WHERE X eid %(x)s',
+{'x': cstr.eid, 'v': value}, 'x',
+ask_confirm=confirm)
+# 2. add new constraints
 for newcstr in newconstraints:
-if newcstr.type() == cstr.type():
+self.rqlexecall(ss.constraint2rql(rschema, subjtype, objtype,
-break
+newcstr),
-else:
+ask_confirm=confirm)
-newcstr = None
+if syncperms and not rschema in VIRTUAL_RTYPES:
-if newcstr is None:
+self._synchronize_permissions(rdef, repordef.eid)
-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):
+def checkpoint(self, ask_confirm=True):
 """checkpoint action"""
-if self.confirm('commit now ?', shell=False):
+if not ask_confirm or self.confirm('Commit now ?', shell=False):
 self.commit()
 def cmd_add_cube(self, cube, update_database=True):
 self.cmd_add_cubes( (cube,), update_database)
 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():
+for (fromtype, totype) in rschema.rdefs:
-if existingschema.has_rdef(fromtype, totype):
+if (fromtype, totype) in existingschema.rdefs:
 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,
 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():
+for fromtype, totype in rschema.rdefs:
-if not removedcubes_schema[rschema.type].has_rdef(fromtype, totype) and \
+if (fromtype, totype) not in removedcubes_schema[rschema.type].rdefs and \
-reposchema[rschema.type].has_rdef(fromtype, totype):
+(fromtype, totype) in reposchema[rschema.type].rdefs:
 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))
 # 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]
+card = eschema.rdef(newname).cardinality[0]
 if card == '1':
 rql += ', NOT X %s NULL' % oldname
 self.rqlexec(rql, ask_confirm=self.verbosity>=2)
 # XXX if both attributes fulltext indexed, should skip fti rebuild
 # XXX if old attribute was fti indexed but not the new one old value
 if eschema.final:
 instschema.del_entity_type(etype)
 else:
 eschema = self.fs_schema.eschema(etype)
 confirm = self.verbosity >= 2
+groupmap = self.group_mapping()
 # register the entity into CWEType
-self.rqlexecall(ss.eschema2rql(eschema), ask_confirm=confirm)
+self.rqlexecall(ss.eschema2rql(eschema, groupmap), 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 instschema:
 # 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),
+self.rqlexecall(ss.rdef2rql(rschema, etype, attrschema.type,
+groupmap=groupmap),
 ask_confirm=confirm)
 # take care to newly introduced base class
 # XXX some part of this should probably be under the "if auto" block
 for spschema in eschema.specialized_by(recursive=False):
 try:
 except KeyError:
 # specialized entity type not in schema, ignore
 continue
 if instspschema.specializes() != eschema:
 self.rqlexec('SET D specializes P WHERE D eid %(d)s, P name %(pn)s',
 {'d': instspschema.eid,
 'pn': eschema.type}, ask_confirm=confirm)
 for rschema, tschemas, role in spschema.relation_definitions(True):
 for tschema in tschemas:
 if not tschema in instschema:
 continue
 if role == 'subject':
 # simply skip here
 continue
 elif role == 'object':
 subjschema = tschema
 objschema = spschema
-if (rschema.rproperty(subjschema, objschema, 'infered')
+if (rschema.rdef(subjschema, objschema).infered
 or (instschema.has_relation(rschema) and
-instschema[rschema].has_rdef(subjschema, objschema))):
+(subjschema, objschema) in instschema[rschema].rdefs)):
 continue
 self.cmd_add_relation_definition(
 subjschema.type, rschema.type, objschema.type)
 if auto:
 # we have commit here to get relation types actually in the schema
 self.commit()
 # 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
+# remember this two avoid adding twice non symmetric relation
 # such as "Emailthread forked_from Emailthread"
 added.append((etype, rschema.type, targettype))
-self.rqlexecall(ss.rdef2rql(rschema, etype, targettype),
+self.rqlexecall(ss.rdef2rql(rschema, etype, targettype,
+groupmap=groupmap),
 ask_confirm=confirm)
 for rschema in eschema.object_relations():
 rtypeadded = rschema.type in instschema or rschema.type in added
 for targetschema in rschema.subjects(etype):
 # ignore relations where the targeted type is not in the
 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),
+self.rqlexecall(ss.rdef2rql(rschema, targettype, etype,
+groupmap=groupmap),
 ask_confirm=confirm)
 if commit:
 self.commit()
 def cmd_drop_entity_type(self, etype, commit=True):
 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),
+self.rqlexecall(ss.rdef2rql(rschema, groupmap=self.group_mapping()),
 ask_confirm=self.verbosity>=2)
 if rtype in META_RTYPES:
 # if the relation is in META_RTYPES, ensure we're adding it for
 # all entity types *in the persistent schema*, not only those in
 # the fs schema
 assert len(objtypes) == 1
 objtype = objtypes[0]
 props = rschema.rproperties(
 rschema.subjects(objtype)[0], objtype)
 assert props
-self.rqlexecall(ss.rdef2rql(rschema, etype, objtype, props),
+self.rqlexecall(ss.rdef2rql(rschema, etype, objtype, props,
+groupmap=self.group_mapping()),
 ask_confirm=self.verbosity>=2)
 if commit:
 self.commit()
 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),
+self.rqlexecall(ss.rdef2rql(rschema, subjtype, objtype,
+groupmap=self.group_mapping()),
 ask_confirm=self.verbosity>=2)
 if commit:
 self.commit()
 def cmd_drop_relation_definition(self, subjtype, rtype, objtype, commit=True):
 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)
+self._synchronize_rdef_schema(ertype[0], ertype[1], ertype[2],
-elif syncprops:
+syncperms=syncperms,
+syncprops=syncprops)
+else:
 erschema = self.repo.schema[ertype]
 if isinstance(erschema, CubicWebRelationSchema):
 self._synchronize_rschema(erschema, syncperms=syncperms,
+syncprops=syncprops,
 syncrdefs=syncrdefs)
+elif syncprops:
+self._synchronize_eschema(erschema, syncperms=syncperms)
 else:
-self._synchronize_eschema(erschema, syncperms=syncperms)
+self._synchronize_permissions(self.fs_schema[ertype], erschema.eid)
-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)
+self._synchronize_permissions(self.fs_schema[etype], etype.eid)
 if commit:
 self.commit()
 def cmd_change_relation_props(self, subjtype, rtype, objtype,
 commit=True, **kwargs):
 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):
+for constr in self.repo.schema.eschema(etype).rdef(rtype).constraints:
 if isinstance(constr, SizeConstraint):
 oldvalue = constr.max
 if oldvalue == size:
 return
 if oldvalue is None and not size is None:
 {'et': etypes[0]})
 if rset:
 return rset.get_entity(0, 0)
 return self.cmd_add_workflow('%s workflow' % ';'.join(etypes), etypes)
-@deprecated('[3.5] use add_workflow and Workflow.add_state method')
+@deprecated('[3.5] use add_workflow and Workflow.add_state method',
+stacklevel=3)
 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)
 """
 wf = self._get_or_create_wf(stateof)
 state = wf.add_state(name, initial, **kwargs)
 if commit:
 self.commit()
 return state.eid
-@deprecated('[3.5] use add_workflow and Workflow.add_transition method')
+@deprecated('[3.5] use add_workflow and Workflow.add_transition method',
+stacklevel=3)
 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
 """
 conditions, **kwargs)
 if commit:
 self.commit()
 return tr.eid
-@deprecated('[3.5] use Transition.set_transition_permissions method')
+@deprecated('[3.5] use Transition.set_transition_permissions method',
+stacklevel=3)
 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
 tr = self._cw.entity_from_eid(treid)
 tr.set_transition_permissions(requiredgroups, conditions, reset)
 if commit:
 self.commit()
-@deprecated('[3.5] use entity.fire_transition("transition") or entity.change_state("state")')
+@deprecated('[3.5] use entity.fire_transition("transition") or entity.change_state("state")',
+stacklevel=3)
 def cmd_set_state(self, eid, statename, commit=False):
 self._cw.entity_from_eid(eid).change_state(statename)
 if commit:
 self.commit()
 entity = self._cw.create_entity(etype, **kwargs)
 if commit:
 self.commit()
 return entity
-@deprecated('use create_entity')
+@deprecated('[3.5] use create_entity', stacklevel=3)
 def cmd_add_entity(self, etype, *args, **kwargs):
 """add a new entity of the given type"""
 return self.cmd_create_entity(etype, *args, **kwargs).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):
+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):
+if self.confirm('Error: %s\nabort?' % ex):
 raise
 return
 try:
 return cu.fetchall()
 except:
 def rqlexec(self, rql, kwargs=None, cachekey=None, ask_confirm=True):
 """rql action"""
 if not isinstance(rql, (tuple, list)):
 rql = ( (rql, kwargs), )
 res = None
+try:
+execute = self._cw.unsafe_execute
+except AttributeError:
+execute = self._cw.execute
 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):
+if not ask_confirm or self.confirm('Execute rql: %s ?' % msg):
 try:
-res = self._cw.execute(rql, kwargs, cachekey)
+res = execute(rql, kwargs, cachekey)
 except Exception, ex:
-if self.confirm('error: %s\nabort?' % 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()
+self.config.disabled_hooks_categories.add('integrity')
 def cmd_reactivate_verification_hooks(self):
-self.repo.hm.reactivate_verification_hooks()
+self.config.disabled_hooks_categories.remove('integrity')
 # 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
 if kwargs:
 msg = '%s (%s)' % (rql, kwargs)
 else:
 msg = rql
 if self.ask_confirm:
-if not self._h.confirm('execute rql: %s ?' % msg):
+if not self._h.confirm('Execute rql: %s ?' % msg):
 raise StopIteration
 try:
 rset = self._h._cw.execute(rql, kwargs)
 except Exception, ex:
-if self._h.confirm('error: %s\nabort?' % ex):
+if self._h.confirm('Error: %s\nabort?' % ex):
 raise
 else:
 raise StopIteration
 self._rsetit = iter(rset)
 return self._rsetit.next()

branch	oldstable
changeset 4985	02b52bf9f5f8
parent 4950	bca0873c0d6e
child 4951	7dc54e12c606