cubicweb: comparison server/schemahooks.py

equal deleted inserted replaced

-:1169d3154be6
+:7ca53fc72a0a
 for i, op in enumerate(self.session.pending_operations):
 if not isinstance(op, MemSchemaEarlyOperation):
 return i
 return i + 1
-class MemSchemaPermissionOperation(MemSchemaOperation):
-"""base class to synchronize schema permission definitions"""
-def __init__(self, session, perm, etype_eid):
-self.perm = perm
-try:
-self.name = session.entity_from_eid(etype_eid).name
-except IndexError:
-self.error('changing permission of a no more existant type #%s',
-etype_eid)
-else:
-Operation.__init__(self, session)
 # operations for high-level source database alteration  ########################
 class SourceDbCWETypeRename(PreCommitOperation):
 # so there is nothing to do here
 if rdef.eid in session.transaction_data.get('neweids', ()):
 return
 subjtype, rtype, objtype = session.schema.schema_by_eid(rdef.eid)
 cstrtype = self.entity.type
-oldcstr = rtype.constraint_by_type(subjtype, objtype, cstrtype)
+oldcstr = rtype.rdef(subjtype, objtype).constraint_by_type(cstrtype)
 newcstr = CONSTRAINTS[cstrtype].deserialize(self.entity.value)
 table = SQL_PREFIX + str(subjtype)
 column = SQL_PREFIX + str(rtype)
 # alter the physical schema on size constraint changes
 if newcstr.type() == 'SizeConstraint' and (
 class MemSchemaCWRTypeAdd(MemSchemaEarlyOperation):
 """actually add the relation type to the instance's schema"""
 eid = None # make pylint happy
 def commit_event(self):
-rschema = self.schema.add_relation_type(self.kobj)
+self.schema.add_relation_type(self.kobj)
-rschema.set_default_groups()
 class MemSchemaCWRTypeUpdate(MemSchemaOperation):
 """actually update some properties of a relation definition"""
 rschema = values = None # make pylint happy
 rschema = values = None # make pylint happy
 def commit_event(self):
 # structure should be clean, not need to remove entity's relations
 # at this point
-self.rschema._rproperties[self.kobj].update(self.values)
+self.rschema.rdef[self.kobj].update(self.values)
 class MemSchemaRDefDel(MemSchemaOperation):
 """actually remove the relation definition from the instance's schema"""
 def commit_event(self):
 self.cancelled = True
 return
 subjtype, rtype, objtype = self.session.schema.schema_by_eid(rdef.eid)
 self.prepare_constraints(subjtype, rtype, objtype)
 cstrtype = self.entity.type
-self.cstr = rtype.constraint_by_type(subjtype, objtype, cstrtype)
+self.cstr = rtype.rdef(subjtype, objtype).constraint_by_type(cstrtype)
 self.newcstr = CONSTRAINTS[cstrtype].deserialize(self.entity.value)
 self.newcstr.eid = self.entity.eid
 def commit_event(self):
 if self.cancelled:
 def commit_event(self):
 self.constraints.remove(self.cstr)
-class MemSchemaPermissionCWGroupAdd(MemSchemaPermissionOperation):
+class MemSchemaPermissionAdd(MemSchemaOperation):
 """synchronize schema when a *_permission relation has been added on a group
 """
-def __init__(self, session, perm, etype_eid, group_eid):
-self.group = session.entity_from_eid(group_eid).name
+def commit_event(self):
-super(MemSchemaPermissionCWGroupAdd, self).__init__(
+"""the observed connections pool has been commited"""
-session, perm, etype_eid)
+try:
+erschema = self.schema.schema_by_eid(self.eid)
+except KeyError:
+# duh, schema not found, log error and skip operation
+self.error('no schema for %s', self.name)
+return
+perms = list(erschema.action_permissions(self.action))
+if hasattr(self, group_eid):
+perm = self.session.entity_from_eid(self.group_eid).name
+else:
+perm = erschema.rql_expression(self.expr)
+try:
+perms.index(perm)
+self.warning('%s already in permissions for %s on %s',
+perm, self.action, erschema)
+except ValueError:
+perms.append(perm)
+erschema.set_action_permissions(self.action, perms)
+class MemSchemaPermissionDel(MemSchemaPermissionAdd):
+"""synchronize schema when a *_permission relation has been deleted from a
+group
+"""
 def commit_event(self):
 """the observed connections pool has been commited"""
 try:
 erschema = self.schema[self.name]
 except KeyError:
 # duh, schema not found, log error and skip operation
 self.error('no schema for %s', self.name)
 return
-groups = list(erschema.get_groups(self.perm))
+perms = list(erschema.action_permissions(self.action))
-try:
+if hasattr(self, group_eid):
-groups.index(self.group)
+perm = self.session.entity_from_eid(self.group_eid).name
-self.warning('group %s already have permission %s on %s',
+else:
-self.group, self.perm, erschema.type)
+perm = erschema.rql_expression(self.expr)
+try:
+perms.remove(self.group)
+erschema.set_action_permissions(self.action, perms)
 except ValueError:
-groups.append(self.group)
+self.error('can\'t remove permission %s for %s on %s',
-erschema.set_groups(self.perm, groups)
+perm, self.action, erschema)
-class MemSchemaPermissionCWGroupDel(MemSchemaPermissionCWGroupAdd):
-"""synchronize schema when a *_permission relation has been deleted from a
-group
-"""
-def commit_event(self):
-"""the observed connections pool has been commited"""
-try:
-erschema = self.schema[self.name]
-except KeyError:
-# duh, schema not found, log error and skip operation
-self.error('no schema for %s', self.name)
-return
-groups = list(erschema.get_groups(self.perm))
-try:
-groups.remove(self.group)
-erschema.set_groups(self.perm, groups)
-except ValueError:
-self.error('can\'t remove permission %s on %s to group %s',
-self.perm, erschema.type, self.group)
-class MemSchemaPermissionRQLExpressionAdd(MemSchemaPermissionOperation):
-"""synchronize schema when a *_permission relation has been added on a rql
-expression
-"""
-def __init__(self, session, perm, etype_eid, expression):
-self.expr = expression
-super(MemSchemaPermissionRQLExpressionAdd, self).__init__(
-session, perm, etype_eid)
-def commit_event(self):
-"""the observed connections pool has been commited"""
-try:
-erschema = self.schema[self.name]
-except KeyError:
-# duh, schema not found, log error and skip operation
-self.error('no schema for %s', self.name)
-return
-exprs = list(erschema.get_rqlexprs(self.perm))
-exprs.append(erschema.rql_expression(self.expr))
-erschema.set_rqlexprs(self.perm, exprs)
-class MemSchemaPermissionRQLExpressionDel(MemSchemaPermissionRQLExpressionAdd):
-"""synchronize schema when a *_permission relation has been deleted from an
-rql expression
-"""
-def commit_event(self):
-"""the observed connections pool has been commited"""
-try:
-erschema = self.schema[self.name]
-except KeyError:
-# duh, schema not found, log error and skip operation
-self.error('no schema for %s', self.name)
-return
-rqlexprs = list(erschema.get_rqlexprs(self.perm))
-for i, rqlexpr in enumerate(rqlexprs):
-if rqlexpr.expression == self.expr:
-rqlexprs.pop(i)
-break
-else:
-self.error('can\'t remove permission %s on %s for expression %s',
-self.perm, erschema.type, self.expr)
-return
-erschema.set_rqlexprs(self.perm, rqlexprs)
 class MemSchemaSpecializesAdd(MemSchemaOperation):
 def commit_event(self):
 meta=entity.get('meta')) # don't care about final
 # fake we add it to the schema now to get a correctly initialized schema
 # but remove it before doing anything more dangerous...
 schema = session.schema
 eschema = schema.add_entity_type(etype)
-eschema.set_default_groups()
 # generate table sql and rql to add metadata
 tablesql = eschema2sql(session.pool.source('system').dbhelper, eschema,
 prefix=SQL_PREFIX)
 relrqls = []
 for rtype in (META_RTYPES - VIRTUAL_RTYPES):
 if not fromeid in session.transaction_data.get('pendingeids', ()):
 schema = session.schema
 entity = session.entity_from_eid(toeid)
 subjtype, rtype, objtype = schema.schema_by_eid(fromeid)
 try:
-cstr = rtype.constraint_by_type(subjtype, objtype,
+cstr = rtype.rdef(subjtype, objtype).constraint_by_type(
 entity.cstrtype[0].name)
 except IndexError:
 session.critical('constraint type no more accessible')
 else:
 SourceDbCWConstraintDel(session, subjtype=subjtype, rtype=rtype,
 objtype=objtype, cstr=cstr)
 # permissions synchronization hooks ############################################
 def after_add_permission(session, subject, rtype, object):
 """added entity/relation *_permission, need to update schema"""
-perm = rtype.split('_', 1)[0]
+action = rtype.split('_', 1)[0]
 if session.describe(object)[0] == 'CWGroup':
-MemSchemaPermissionCWGroupAdd(session, perm, subject, object)
+MemSchemaPermissionAdd(session, action=action, eid=subject,
+group_eid=object)
 else: # RQLExpression
-expr = session.execute('Any EXPR WHERE X eid %(x)s, X expression EXPR',
+expr = session.entity_from_eid(object).expression
-{'x': object}, 'x')[0][0]
+MemSchemaPermissionAdd(session, action=action, eid=subject,
-MemSchemaPermissionRQLExpressionAdd(session, perm, subject, expr)
+expr=expr)
 def before_del_permission(session, subject, rtype, object):
 """delete entity/relation *_permission, need to update schema
 skip the operation if the related type is being deleted
 """
 if subject in session.transaction_data.get('pendingeids', ()):
 return
-perm = rtype.split('_', 1)[0]
+action = rtype.split('_', 1)[0]
 if session.describe(object)[0] == 'CWGroup':
-MemSchemaPermissionCWGroupDel(session, perm, subject, object)
+MemSchemaPermissionDel(session, action=action, eid=subject, group_eid=object)
 else: # RQLExpression
-expr = session.execute('Any EXPR WHERE X eid %(x)s, X expression EXPR',
+expr = session.entity_from_eid(object).expression
-{'x': object}, 'x')[0][0]
+MemSchemaPermissionDel(session, action=action, eid=subject, expr=expr)
-MemSchemaPermissionRQLExpressionDel(session, perm, subject, expr)
 def after_add_specializes(session, subject, rtype, object):
 MemSchemaSpecializesAdd(session, etypeeid=subject, parentetypeeid=object)

branch	reldefsecurity
changeset 3877	7ca53fc72a0a
parent 3870	a6b029aa0f44
child 3889	8902b8745918