cubicweb: comparison server/migractions.py

equal deleted inserted replaced

-:f94b41709ce6
+:b056a49c16dc
 from cubicweb.server.utils import manager_userpasswd
 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
 """
 @cached
 def repo_connect(self):
 self.repo = get_repository(method='inmemory', config=self.config)
 return self.repo
 def shutdown(self):
 if self.repo is not None:
 self.repo.shutdown()
 def rewrite_vcconfiguration(self):
 """write current installed versions (of cubicweb software
 and of each used cube) into the database
 """
 self.cmd_set_property('system.version.cubicweb', self.config.cubicweb_version())
 for pkg in self.config.cubes():
 pkgversion = self.config.cube_version(pkg)
 self.cmd_set_property('system.version.%s' % pkg.lower(), pkgversion)
 self.commit()
 def backup_database(self, backupfile=None, askconfirm=True):
 config = self.config
 source = config.sources()['system']
 helper = get_adv_func_helper(source['db-driver'])
 date = datetime.now().strftime('%Y-%m-%d_%H:%M:%S')
 else:
 from cubicweb.toolsutils import restrict_perms_to_user
 print 'database backup:', backupfile
 restrict_perms_to_user(backupfile, self.info)
 break
 def restore_database(self, backupfile, drop=True):
 config = self.config
 source = config.sources()['system']
 helper = get_adv_func_helper(source['db-driver'])
 app = config.appid
 if answer == 1: # 1: continue, 2: retry
 break
 else:
 break
 print 'database restored'
 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
 """
 if self.execscript_confirm(migrscript):
 sqlexec(open(migrscript).read(), self.session.system_sql)
 else:
 return super(ServerMigrationHelper, self).process_script(
 migrscript, funcname, *args, **kwargs)
 @property
 def cnx(self):
 """lazy connection"""
 try:
 return self._cnx
 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
 @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):
 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 ('eid', 'has_text', 'identity'):
 return
 newrschema = self.fs_schema[ertype]
 '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
 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`
 """
 # 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 application, so the
 cube schema is already in there)
 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
 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(
 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)
 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:
 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
 # 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},
 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),
 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),
 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():
 '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:
 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.
 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
 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
 entity type(s)
 """
 stateeid = self.cmd_add_entity('State', name=name, **kwargs)
 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
 """
 self.session.set_pool() # ensure pool is set
 entity = self.session.eid_rset(eid).get_entity(0, 0)
 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)
 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 = []
 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:
 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
 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:
 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
 """
 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
 """
 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:

branch	tls-sprint
changeset 1477	b056a49c16dc
parent 1414	448c9802d7df
parent 1278	10fa95dd91ab
child 1790	a3e2b079de00