cubicweb: comparison server/migractions.py

equal deleted inserted replaced

-:5fe84a5f7035
+:3f408c7a164e
 import sys
 import os
 from os.path import join, exists
 from datetime import datetime
+from logilab.common.deprecation import deprecated_function, obsolete
 from logilab.common.decorators import cached
 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 CubicWebRelationSchema
 from cubicweb.dbapi import get_repository, repo_connect
 from cubicweb.common.migration import MigrationHelper, yes
 try:
 from cubicweb.server import schemaserial as ss
 context.update({'checkpoint': self.checkpoint,
 'sql': self.sqlexec,
 'rql': self.rqlexec,
 'rqliter': self.rqliter,
 'schema': self.repo.schema,
-# XXX deprecate
-'newschema': self.fs_schema,
 'fsschema': self.fs_schema,
-'cnx': self.cnx,
 'session' : self.session,
 'repo' : self.repo,
+'synchronize_schema': deprecated_function(self.sync_schema_props_perms),
+'synchronize_eschema': deprecated_function(self.sync_schema_props_perms),
+'synchronize_rschema': deprecated_function(self.sync_schema_props_perms),
 })
 return context
 @cached
 def group_mapping(self):
 if self.config.free_wheel:
 self.repo.hm.register_hook(setowner_after_add_entity,
 'after_add_entity', '')
 self.reactivate_verification_hooks()
-# base actions ############################################################
+# schema synchronization internals ########################################
-def checkpoint(self):
+def _synchronize_permissions(self, ertype):
-"""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 application, so the
-cube schema is already in there)
-"""
-newcubes = super(ServerMigrationHelper, self).cmd_add_cubes(cubes)
-if not newcubes:
-return
-for pack in newcubes:
-self.cmd_set_property('system.version.'+pack,
-self.config.cube_version(pack))
-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):
-removedcubes = super(ServerMigrationHelper, self).cmd_remove_cube(cube)
-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 ('eid', 'creation_date', 'modification_date'):
-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 ('owned_by', 'created_by', 'is', 'is_instance_of'):
-continue
-rtypeadded = rschema.type in applschema
-for targetschema in rschema.objects(etype):
-# ignore relations where the targeted type is not in the
-# current application 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 application 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})
-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_synchronize_permissions(self, ertype, commit=True):
 """permission synchronization for an entity or relation type"""
 if ertype in ('eid', 'has_text', 'identity'):
 return
 newrschema = self.fs_schema[ertype]
 teid = self.repo.schema[ertype].eid
 '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)
-if commit:
-self.commit()
+def _synchronize_rschema(self, rtype, syncrdefs=True, syncperms=True):
-def cmd_synchronize_rschema(self, rtype, syncrdefs=True, syncperms=True,
-commit=True):
 """synchronize properties of the persistent relation schema against its
 current definition:
 * description
 * symetric, meta
 reporschema = self.repo.schema.rschema(rtype)
 if syncrdefs:
 for subj, obj in rschema.iter_rdefs():
 if not reporschema.has_rdef(subj, obj):
 continue
-self.cmd_synchronize_rdef_schema(subj, rschema, obj,
+self._synchronize_rdef_schema(subj, rschema, obj)
-commit=False)
 if syncperms:
-self.cmd_synchronize_permissions(rtype, commit=False)
+self._synchronize_permissions(rtype)
-if commit:
-self.commit()
-def cmd_synchronize_eschema(self, etype, syncperms=True, commit=True):
+def _synchronize_eschema(self, etype, syncperms=True):
 """synchronize properties of the persistent entity schema against
 its current definition:
 * description
 * internationalizable, fulltextindexed, indexed, meta
 subjtypes, objtypes = [etype], targettypes
 else: # x == 'object'
 if not rschema in repoeschema.object_relations():
 continue
 subjtypes, objtypes = targettypes, [etype]
-self.cmd_synchronize_rschema(rschema, syncperms=syncperms,
+self._synchronize_rschema(rschema, syncperms=syncperms,
-syncrdefs=False, commit=False)
+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.cmd_synchronize_rdef_schema(subj, rschema, obj,
+self._synchronize_rdef_schema(subj, rschema, obj,
 commit=False)
 if syncperms:
-self.cmd_synchronize_permissions(etype, commit=False)
+self._synchronize_permissions(etype)
-if commit:
-self.commit()
+def _synchronize_rdef_schema(self, subjtype, rtype, objtype):
-def cmd_synchronize_rdef_schema(self, subjtype, rtype, objtype,
-commit=True):
 """synchronize properties of the persistent relation definition schema
 against its current definition:
 * order and other properties
 * constraints
 """
 # 2. add new constraints
 for newcstr in newconstraints:
 self.rqlexecall(ss.constraint2rql(rschema, subjtype, objtype,
 newcstr),
 ask_confirm=confirm)
-if commit:
-self.commit()
+# base actions ############################################################
-def cmd_synchronize_schema(self, syncperms=True, commit=True):
+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 application, so the
+cube schema is already in there)
+"""
+newcubes = super(ServerMigrationHelper, self).cmd_add_cubes(cubes)
+if not newcubes:
+return
+for pack in newcubes:
+self.cmd_set_property('system.version.'+pack,
+self.config.cube_version(pack))
+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):
+removedcubes = super(ServerMigrationHelper, self).cmd_remove_cube(cube)
+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 ('eid', 'creation_date', 'modification_date'):
+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 ('owned_by', 'created_by', 'is', 'is_instance_of'):
+continue
+rtypeadded = rschema.type in applschema
+for targetschema in rschema.objects(etype):
+# ignore relations where the targeted type is not in the
+# current application 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 application 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})
+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.
 """
-for etype in self.repo.schema.entities():
+assert syncperms or syncprops, 'nothing to do'
-self.cmd_synchronize_eschema(etype, syncperms=syncperms, commit=False)
+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"""
+"""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':
 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
+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
 ask_confirm=self.verbosity>=2)
 # cleanup unused constraints
 self.rqlexec('DELETE CWConstraint C WHERE NOT X constrained_by C')
 if commit:
 self.commit()
+@obsolete('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

branch	tls-sprint
changeset 1399	3f408c7a164e
parent 1398	5fe84a5f7035
child 1409	f4dee84a618f