cubicweb: comparison server/migractions.py

equal deleted inserted replaced

-:73760bbb66bd
+:78438ad513ca
 if hasattr(self, '_cnx'):
 self._cnx.rollback()
 if self.session:
 self.session.set_pool()
-def rqlexecall(self, rqliter, cachekey=None, ask_confirm=True):
+def rqlexecall(self, rqliter, ask_confirm=True):
 for rql, kwargs in rqliter:
-self.rqlexec(rql, kwargs, cachekey, ask_confirm=ask_confirm)
+self.rqlexec(rql, kwargs, ask_confirm=ask_confirm)
 @cached
 def _create_context(self):
 """return a dictionary to use as migration script execution context"""
 context = super(ServerMigrationHelper, self)._create_context()
 for action in erschema.ACTIONS:
 perm = '%s_permission' % action
 # handle groups
 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',
+'T eid %%(x)s' % perm, {'x': teid},
 ask_confirm=False):
 if not gname in newgroups:
 if not confirm or self.confirm('Remove %s permission of %s to %s?'
 % (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)
+{'x': geid}, 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, 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)
+{'x': gm[gname]}, ask_confirm=False)
 # handle rql expressions
 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 confirm or self.confirm('Remove %s expression for %s permission of %s?'
 % (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)
+{'x': expreid}, 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, 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',
+'vars': expression.mainvars, 'x': teid},
 ask_confirm=False)
 def _synchronize_rschema(self, rtype, syncrdefs=True, syncperms=True, syncprops=True):
 """synchronize properties of the persistent relation schema against its
 current definition:
 break
 else:
 newcstr = None
 if newcstr is None:
 self.rqlexec('DELETE X constrained_by C WHERE C eid %(x)s',
-{'x': cstr.eid}, 'x',
+{'x': cstr.eid}, ask_confirm=confirm)
-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',
+{'x': cstr.eid, 'v': value},
 ask_confirm=confirm)
 # 2. add new constraints
 cstrtype_map = self.cstrtype_mapping()
 self.rqlexecall(ss.constraints2rql(cstrtype_map, newconstraints,
 repordef.eid),
 if (fromtype, totype) not in removedcubes_schema[rschema.type].rdefs and \
 (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):
+for cube in reversed(removedcubes):
-self.exec_event_script('postremove', self.config.cube_dir(pack))
+self.exec_event_script('postremove', self.config.cube_dir(cube))
 self.rqlexec('DELETE CWProperty X WHERE X pkey %(pk)s',
-{'pk': u'system.version.'+pack}, ask_confirm=False)
+{'pk': u'system.version.'+cube}, ask_confirm=False)
 self.commit()
 # schema migration actions ################################################
 def cmd_add_attribute(self, etype, attrname, attrtype=None, commit=True):
 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,
+{'d': instspschema.eid, 'pn': eschema.type},
-'pn': eschema.type}, ask_confirm=confirm)
+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':
 if not isinstance(wfof, (list, tuple)):
 wfof = (wfof,)
 for etype in wfof:
 rset = self.rqlexec(
 'SET X workflow_of ET WHERE X eid %(x)s, ET name %(et)s',
-{'x': wf.eid, 'et': etype}, 'x', ask_confirm=False)
+{'x': wf.eid, 'et': etype}, ask_confirm=False)
 assert rset, 'unexistant entity type %s' % etype
 if default:
 self.rqlexec(
 'SET ET default_workflow X WHERE X eid %(x)s, ET name %(et)s',
-{'x': wf.eid, 'et': etype}, 'x', ask_confirm=False)
+{'x': wf.eid, 'et': etype}, ask_confirm=False)
 if commit:
 self.commit()
 return wf
 # XXX remove once cmd_add_[state|transition] are removed
 return
 def rqlexec(self, rql, kwargs=None, cachekey=None, build_descr=True,
 ask_confirm=True):
 """rql action"""
+if cachekey is not None:
+warn('[3.8] cachekey is deprecated, you can safely remove this argument',
+DeprecationWarning, stacklevel=2)
 if not isinstance(rql, (tuple, list)):
 rql = ( (rql, kwargs), )
 res = None
 execute = self._cw.execute
 for rql, kwargs in rql:
 msg = '%s (%s)' % (rql, kwargs)
 else:
 msg = rql
 if not ask_confirm or self.confirm('Execute rql: %s ?' % msg):
 try:
-res = execute(rql, kwargs, cachekey, build_descr=build_descr)
+res = execute(rql, kwargs, build_descr=build_descr)
 except Exception, ex:
 if self.confirm('Error: %s\nabort?' % ex):
 raise
 return res

changeset 5174	78438ad513ca
parent 5132	260d73ad4f24
child 5302	dfd147de06b2