cubicweb: comparison server/migractions.py

equal deleted inserted replaced

-:29f74716fd70
+:5376aaadd16b
 """
 def __init__(self, config, schema, interactive=True,
 repo=None, cnx=None, verbosity=1, connect=True):
 MigrationHelper.__init__(self, config, interactive, verbosity)
+# no config on shell to a remote instance
 if not interactive:
 assert cnx
 assert repo
 if cnx is not None:
 assert repo
 self._cnx = cnx
 self.repo = repo
-self.session.data['rebuild-infered'] = False
+if config is not None:
+self.session.data['rebuild-infered'] = False
 elif connect:
 self.repo_connect()
 if not schema:
 schema = config.load_schema(expand_cubes=True)
 self.fs_schema = schema
 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):
+def cmd_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(
+return super(ServerMigrationHelper, self).cmd_process_script(
 migrscript, funcname, *args, **kwargs)
 self.commit()
 except:
 self.rollback()
 raise
 self.session.data['rebuild-infered'] = False
 return self._cnx
 @property
 def session(self):
-return self.repo._get_session(self.cnx.sessionid)
+if self.config is not None:
+return self.repo._get_session(self.cnx.sessionid)
+# no access to session on remote instance
+return None
 def commit(self):
 if hasattr(self, '_cnx'):
 self._cnx.commit()
 context = super(ServerMigrationHelper, self)._create_context()
 context.update({'checkpoint': self.checkpoint,
 'sql': self.sqlexec,
 'rql': self.rqlexec,
 'rqliter': self.rqliter,
-'schema': self.repo.schema,
+'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), # 3.4
 'synchronize_eschema': deprecated()(self.cmd_sync_schema_props_perms), # 3.4
 return context
 @cached
 def group_mapping(self):
 """cached group mapping"""
-self.session.set_pool()
+return ss.group_mapping(self._cw)
-return ss.group_mapping(self.session)
 def exec_event_script(self, event, cubepath=None, funcname=None,
 *args, **kwargs):
 if cubepath:
 apc = osp.join(cubepath, 'migration', '%s.py' % event)
 confirm = self.confirm
 execscript_confirm = self.execscript_confirm
 self.confirm = yes
 self.execscript_confirm = yes
 try:
-return self.process_script(apc, funcname, *args, **kwargs)
+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,
 """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():
+if 'update' in newrschema.ACTIONS or newrschema.final:
 # entity type
 exprtype = u'ERQLExpression'
 else:
 # relation type
 exprtype = u'RRQLExpression'
 instschema = self.repo.schema
 if etype in instschema:
 # XXX (syt) plz explain: if we're adding an entity type, it should
 # not be there...
 eschema = instschema[etype]
-if eschema.is_final():
+if eschema.final:
 instschema.del_entity_type(etype)
 else:
 eschema = self.fs_schema.eschema(etype)
 confirm = self.verbosity >= 2
 # register the entity into CWEType
 if not tschema in instschema:
 continue
 if role == 'subject':
 subjschema = spschema
 objschema = tschema
-if rschema.final and instspschema.has_subject_relation(rschema):
+if rschema.final and rschema in instspschema.subjrels:
 # attribute already set, has_rdef would check if
 # it's of the same type, we don't want this so
 # simply skip here
 continue
 elif role == 'object':
 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():
+if rschema.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"')
 for the specified entity type(s); set it to false in
 the case of a subworkflow
 :rtype: `Workflow`
 """
-self.session.set_pool() # ensure pool is set
 wf = self.cmd_create_entity('Workflow', name=unicode(name),
 **kwargs)
 if not isinstance(wfof, (list, tuple)):
 wfof = (wfof,)
 for etype in wfof:
 self.commit()
 return wf
 # XXX remove once cmd_add_[state|transition] are removed
 def _get_or_create_wf(self, etypes):
-self.session.set_pool() # ensure pool is set
 if not isinstance(etypes, (list, tuple)):
 etypes = (etypes,)
 rset = self.rqlexec('Workflow X WHERE X workflow_of ET, ET name %(et)s',
 {'et': etypes[0]})
 if rset:
 requiredgroups=(), conditions=(),
 reset=True, commit=False):
 """set or add (if `reset` is False) groups and conditions for a
 transition
 """
-self.session.set_pool() # ensure pool is set
+tr = self._cw.entity_from_eid(treid)
-tr = self.session.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")')
 def cmd_set_state(self, eid, statename, commit=False):
-self.session.set_pool() # ensure pool is set
+self._cw.entity_from_eid(eid).change_state(statename)
-self.session.entity_from_eid(eid).change_state(statename)
 if commit:
 self.commit()
 # CWProperty handling ######################################################
 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_create_entity(self, etype, *args, **kwargs):
+@property
+def _cw(self):
+session = self.session
+if session is not None:
+session.set_pool()
+return session
+return self.cnx.request()
+def cmd_create_entity(self, etype, **kwargs):
 """add a new entity of the given type"""
 commit = kwargs.pop('commit', False)
-self.session.set_pool()
+entity = self._cw.create_entity(etype, **kwargs)
-entity = self.session.create_entity(etype, *args, **kwargs)
 if commit:
 self.commit()
 return entity
 @deprecated('use create_entity')
 def rqlexec(self, rql, kwargs=None, cachekey=None, ask_confirm=True):
 """rql action"""
 if not isinstance(rql, (tuple, list)):
 rql = ( (rql, kwargs), )
 res = None
-self.session.set_pool()
 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.session.execute(rql, kwargs, cachekey)
+res = self._cw.execute(rql, kwargs, cachekey)
 except Exception, ex:
 if self.confirm('error: %s\nabort?' % ex):
 raise
 return res
 else:
 msg = rql
 if self.ask_confirm:
 if not self._h.confirm('execute rql: %s ?' % msg):
 raise StopIteration
-self._h.session.set_pool()
 try:
-rset = self._h.session.execute(rql, kwargs)
+rset = self._h._cw.execute(rql, kwargs)
 except Exception, ex:
 if self._h.confirm('error: %s\nabort?' % ex):
 raise
 else:
 raise StopIteration

changeset 3720	5376aaadd16b
parent 3659	993997b4b41d
parent 3715	e3ccadb126d7
child 3890	d7a270f50f54