def execute(self, args): for path in args.paths: obj_dir = self.current_obj # cleanup trailing slash if path.endswith('/'): path = path[:-1] if os.path.dirname(path): obj_dir = self.traverse(os.path.dirname(path)) obj = obj_dir[os.path.basename(path)] if not obj_dir or not obj: self.write("No such object: %s\n" % path) continue parent = obj.__parent__ del obj_dir[obj.__name__] try: handle(obj, ModelDeletedEvent(parent)) except Exception: if not args.f: raise
def init(test=False): global _db, _testing if _db and not test: return log.info("Initializing zodb") handle(BeforeDatabaseInitalizedEvent()) if not test: storage_type = get_config().get('db', 'storage_type') if storage_type == 'zeo': from ZODB import DB storage = ClientStorage('%s/socket' % get_db_dir()) _db = DB(storage) elif storage_type == 'embedded': from ZODB import DB storage = FileStorage('%s/data.fs' % get_db_dir()) _db = DB(storage) elif storage_type == 'memory': from ZODB.tests.util import DB _db = DB() else: raise Exception("Unknown storage type '%s'" % storage_type) else: from ZODB.tests.util import DB _db = DB() _testing = True init_schema()
def demo_events(load_zcml): gsm = getGlobalSiteManager() if load_zcml: from zope.configuration.xmlconfig import xmlconfig fname = __file__[:-3] + '.zcml' xmlconfig(open(fname)) else: gsm.registerHandler(me.handle_some_event) gsm.registerHandler(me.handle_object_modified_event, [me.IData, me.IObjectModifiedEvent]) obj = me.Data() evt = me.SomeEvent() evt.object = obj if load_zcml: notify(evt) else: handle(evt) assert obj.data == 'changed' obj.data = 'unchanged' if load_zcml: notify(me.ObjectModifiedEvent(obj)) else: objectEventNotify(me.ObjectModifiedEvent(obj)) assert obj.data == 'changed' print "Done"
def __init__(self): """Initialize the transaction. If this is the first transaction in the stack, a TransactionBegin event is emited.""" self._need_rollback = False if not self._stack: component.handle(TransactionBegin()) self._stack.append(self)
def set_owner(self, principal): prinrole = interfaces.IPrincipalRoleManager(self) oldowner = self.__owner__ prinrole.unsetRoleForPrincipal('owner', oldowner) prinrole.assignRoleToPrincipal('owner', principal.id) if (not hasattr(self, '__suppress_events') and principal is not None and principal.id != oldowner): handle(self, OwnerChangedEvent(oldowner, principal.id))
def rollback(self): """Roll-back the transaction. First, the transaction is closed. Every transaction on the stack is then marked for roll-back. If the stack is empty, a TransactionRollback event is emited.""" self._close() for tx in self._stack: tx._need_rollback = True if not self._stack: component.handle(TransactionRollback())
def _verifyImport(self, obj): adapted = queryAdapter(object(), IAnotherDummy2) self.failUnless(IAnotherDummy2.providedBy(adapted)) self.failUnless(adapted.verify()) adapted = queryAdapter(object(), IAnotherDummy2, name=u'foo') self.failUnless(IAnotherDummy2.providedBy(adapted)) self.failUnless(adapted.verify()) dummy = DummyObject() results = [adap.verify() for adap in subscribers([dummy], IAnotherDummy2)] self.assertEquals(results, [True]) dummy = DummyObject() handle(dummy) self.assertEquals(dummy.handled, 1) util = queryUtility(IDummyInterface2, name=u'foo') self.failUnless(IDummyInterface.providedBy(util)) self.failUnless(util.verify()) self.failUnless(util.__parent__ == obj) name = ('Products.GenericSetup.tests.test_components.' 'IDummyInterface2-foo') self.assertEquals(util.__name__, name) self.failUnless(name in obj.objectIds()) util = queryUtility(IDummyInterface) self.failUnless(IDummyInterface.providedBy(util)) self.failUnless(util.verify()) self.failUnless(util.__parent__ == obj) name = 'dummy_utility' self.assertEquals(util.__name__, name) self.failUnless(name in obj.objectIds()) util = queryUtility(IDummyInterface, name='dummy tool name') self.failUnless(IDummyInterface.providedBy(util)) self.failUnless(util.verify()) self.assertEqual(util.meta_type, 'dummy tool') # make sure we can get the tool by normal means tool = getattr(obj.aq_parent, 'dummy_tool') self.assertEqual(tool.meta_type, 'dummy tool') self.assertEquals(repr(aq_base(util)), repr(aq_base(tool))) util = queryUtility(IDummyInterface2, name='dummy tool name2') self.failUnless(IDummyInterface2.providedBy(util)) self.failUnless(util.verify()) self.assertEqual(util.meta_type, 'dummy tool2') # make sure we can get the tool by normal means tool = getattr(obj.aq_parent, 'dummy_tool2') self.assertEqual(tool.meta_type, 'dummy tool2') self.assertEquals(repr(aq_base(util)), repr(aq_base(tool)))
def commit(self): """Commit the transaction. First, the transaction is closed. If it needs to be rolled-back, a TransactionRollback event is emited. Otherwise, a TransactionCommit event is emited.""" self._close() if not self._stack: if self._need_rollback: component.handle(TransactionRollback()) else: component.handle(TransactionCommit())
def new_local_site_dispatcher(event): """ Dispatches just like an object event, that way we can do things based on the type of the site manager. Note that if the containing ISite is (re)moved, an ObjectEvent will be fired for (sitemanager, site-event); that is, you subscribe to the site manager and the object moved event, but the event will have the ISite as the object property. """ component.handle(event.manager, event)
def notifyFieldEvent(event): field = event.field if IFieldRenderEvent.providedBy(event): event.value = getMultiAdapter((field, event), IFieldValue) if event.kwargs.get('raw', False) or getattr(event, 'raw', False): # bail out return handle(event.field, event.instance, event) if IFieldStorageEvent.providedBy(event): for ignore in subscribers((field, event), IFieldValueSetter): pass
def add(self, item): if not self.can_contain(item): raise Exception("Can only contain instances or providers of %s" % self.__contains__.__name__) old_parent = item.__parent__ res = self._add(item) if not hasattr(self, '__suppress_events'): if old_parent is not None and old_parent is not self: handle(item, ModelMovedEvent(item.__parent__, self)) else: handle(item, ModelCreatedEvent(self)) return res
def before_object_assigned_event_dispatcher(event): """ Listens for :mod:`zope.schema` fields to fire :class:`~nti.schema.interfaces.IBeforeSchemaFieldAssignedEvent`, and re-dispatches these events based on the value being assigned, the object being assigned to, and of course the event (note that :class:`~zope.schema.interfaces.IBeforeObjectAssignedEvent` is a sub-interface of :class:`~nti.schema.interfaces.IBeforeSchemaFieldAssignedEvent`). This is analogous to :func:`zope.component.event.objectEventNotify` """ handle(event.object, event.context, event)
def render_DELETE(self, request): force = request.args.get('force', ['false'])[0] == 'true' parent = self.context.__parent__ del parent[self.context.__name__] try: handle(self.context, ModelDeletedEvent(parent)) except Exception as e: if not force: raise e return {'status': 'failure'} return {'status': 'success'}
def main(): gsm.registerHandler(docCreated) gsm.registerHandler(docCreated2) documents = (('doc1', Document('a document one', 'Всем привет. Буквально пару слов обо мне.')), ('doc2', Document('a document two', 'Сейчас я переехал в Германию и работаю в InnoGames.')), ('doc3', Document('a document three', 'И сегодня мы поговорим с вами.'))) # create documents for _, d in documents: sleep(0.5) handle(DocumentCreated(d)) print('attributes of created documents:') for n, d in documents: print('Document {!r}'.format(n)) print_attrs(d) print()
def test_remove_components(self): from Products.GenericSetup.components import importComponentRegistry obj = self._obj self._populate(obj) self._verifyImport(obj) context = DummyImportContext(obj, False) context._files['componentregistry.xml'] = _REMOVE_IMPORT importComponentRegistry(context) adapted = queryAdapter(object(), IAnotherDummyInterface2) self.failUnless(adapted is None) # This one should still exist adapted = queryAdapter(object(), IAnotherDummyInterface2, name=u'foo') self.failIf(adapted is None) dummy = DummyObject() results = [ adap.verify() for adap in subscribers([dummy], IAnotherDummyInterface2) ] self.assertEquals(results, []) dummy = DummyObject() handle(dummy) self.assertEquals(dummy.handled, 0) util = queryUtility(IDummyInterface2, name=u'foo') name = 'Products.GenericSetup.tests.test_components.IDummyInterface2-foo' self.failUnless(util is None) self.failIf(name in obj.objectIds()) util = queryUtility(IDummyInterface) self.failUnless(util is None) self.failIf('dummy_utility' in obj.objectIds()) util = queryUtility(IDummyInterface, name='dummy tool name') self.failUnless(util is None) # This one should still exist util = queryUtility(IDummyInterface2, name='dummy tool name2') self.failIf(util is None)
def test_remove_components(self): from Products.GenericSetup.components import importComponentRegistry obj = self._obj self._populate(obj) self._verifyImport(obj) context = DummyImportContext(obj, False) context._files['componentregistry.xml'] = _REMOVE_IMPORT importComponentRegistry(context) adapted = queryAdapter(object(), IAnotherDummy2) self.failUnless(adapted is None) # This one should still exist adapted = queryAdapter(object(), IAnotherDummy2, name=u'foo') self.failIf(adapted is None) dummy = DummyObject() results = [adap.verify() for adap in subscribers([dummy], IAnotherDummy2)] self.assertEquals(results, []) dummy = DummyObject() handle(dummy) self.assertEquals(dummy.handled, 0) util = queryUtility(IDummyInterface2, name=u'foo') name = ('Products.GenericSetup.tests.test_components.' 'IDummyInterface2-foo') self.failUnless(util is None) self.failIf(name in obj.objectIds()) util = queryUtility(IDummyInterface) self.failUnless(util is None) self.failIf('dummy_utility' in obj.objectIds()) util = queryUtility(IDummyInterface, name='dummy tool name') self.failUnless(util is None) # This one should still exist util = queryUtility(IDummyInterface2, name='dummy tool name2') self.failIf(util is None)
class TmpObj(object): """A proxy for storing and remembering temporary modifications to objects, and later applying them to the wrapped object. """ __allowed_attrs__ = ['__markers__'] def __init__(self, wrapped, cls=None): self.__dict__['obj'] = wrapped self.__dict__['cls'] = cls self.__dict__['modified_attrs'] = {} def __getattr__(self, name): if name.startswith('__') and name not in TmpObj.__allowed_attrs__: raise AttributeError(name) if name in self.__dict__['modified_attrs']: return self.__dict__['modified_attrs'][name] else: obj = self.__dict__['obj'] if not obj: # try to access class methods cls_method = getattr(self.__dict__['cls'], name, None) return cls_method if inspect.isroutine(cls_method) else None return getattr(obj, name) if obj else None def __setattr__(self, name, value): if getattr(self, name, object()) != value: self.__dict__['modified_attrs'][name] = value # ingore_readonly is needed to restore objects with readonly fields # using importexport without issues. It really makes it ignore all # AttributeErrors def apply(self, ignore_readonly=False): original_attrs = {} for name, value in self.__dict__['modified_attrs'].items(): original_attrs[name] = getattr(self.__dict__['obj'], name, None) try: setattr(self.__dict__['obj'], name, value) except AttributeError, e: log.error('%s: %s=%s', e, name, value) if not ignore_readonly: raise # properties could alter the effective value of what we set # so we need to read back the actual values from the object updated = {} for k in self.__dict__['modified_attrs'].keys(): new_value = getattr(self.__dict__['obj'], k) if new_value != original_attrs[k]: updated[k] = getattr(self.__dict__['obj'], k) # we emit modification events only for objects # that have been already added to a container (ON-412) if updated and self.__dict__['obj'].__parent__: handle(self.__dict__['obj'], ModelModifiedEvent(original_attrs, updated))
def render_delete(self, request): name = unicode(parse_path(request.path)[-1]) existing_object = self.context.__parent__[name] if existing_object: log.debug('Deleting %s', self.context) # are we deleting a container? if IStorageContainer.providedBy(self.context): # check children children = [child for child in self.context.listcontent() if IDataObject.providedBy(child) or IStorageContainer.providedBy(child)] if len(children) > 0: raise BadRequest('Attempt to delete a non-empty container') else: # XXX: Alternative authentication methods! credentials = request.getHeader('X-Auth-Token') storemgr = getAdapter(self.context, IDataStoreFactory).create() storemgr.delete(credentials) del self.context.__parent__[name] handle(self.context, ModelDeletedEvent(self.context.__parent__)) else: raise NotFound
def main(): gsm.registerHandler(docCreated) gsm.registerHandler(docCreated2) documents = (('doc1', Document('a document one', 'Всем привет. Буквально пару слов обо мне.')), ('doc2', Document( 'a document two', 'Сейчас я переехал в Германию и работаю в InnoGames.')), ('doc3', Document('a document three', 'И сегодня мы поговорим с вами.'))) # create documents for _, d in documents: sleep(0.5) handle(DocumentCreated(d)) print('attributes of created documents:') for n, d in documents: print('Document {!r}'.format(n)) print_attrs(d) print()
def _callFUT(self, *args, **kw): from zope.component import handle return handle(*args, **kw)
def _sync_vms_transact(self, remote_vms): local_vms = [i for i in self.context.listcontent() if IVirtualCompute.providedBy(i)] remote_uuids = set(i['uuid'] for i in remote_vms) local_uuids = set(i.__name__ for i in local_vms) root = db.get_root()['oms_root'] machines = root['machines'] for vm_uuid in remote_uuids.difference(local_uuids): remote_vm = [rvm for rvm in remote_vms if rvm['uuid'] == vm_uuid][0] existing_machine = follow_symlinks(machines['by-name'][remote_vm['name']]) if existing_machine: # XXX: this VM is a nested VM, for now let's hack it this way new_compute = Symlink(existing_machine.__name__, existing_machine) self.context._add(new_compute) else: log.msg('Adding virtual compute %s...' % vm_uuid, system='v12n-sync', logLevel=logging.WARNING) new_compute = Compute(unicode(remote_vm['name']), unicode(remote_vm['state'])) new_compute.__name__ = vm_uuid new_compute.template = unicode(remote_vm['template']) alsoProvides(new_compute, IVirtualCompute) alsoProvides(new_compute, IDeployed) # for now let's force new synced computes to not have salt installed # XXX: not sure if removing a parent interface will remove the child also noLongerProvides(new_compute, IManageable) self.context.add(new_compute) for vm_uuid in remote_uuids.intersection(local_uuids): noLongerProvides(self.context[vm_uuid], IUndeployed) alsoProvides(self.context[vm_uuid], IDeployed) for vm_uuid in local_uuids.difference(remote_uuids): if IDeploying.providedBy(self.context[vm_uuid]): log.msg("Don't delete undeployed VM while in IDeploying state", system='v12n') continue noLongerProvides(self.context[vm_uuid], IDeployed) alsoProvides(self.context[vm_uuid], IUndeployed) self.context[vm_uuid].state = u'inactive' if get_config().getboolean('sync', 'delete_on_sync'): log.msg("Deleting compute %s" % vm_uuid, system='v12n-sync', logLevel=logging.WARNING) compute = self.context[vm_uuid] del self.context[vm_uuid] handle(compute, ModelDeletedEvent(self.context)) # TODO: eliminate cross-import between compute and v12ncontainer from opennode.knot.backend.compute import ICompute from opennode.knot.backend.syncaction import SyncAction # sync each vm for compute in self.context.listcontent(): if not IVirtualCompute.providedBy(compute): continue log.msg('Attempting to sync %s' % compute, system='sync-vms') if not ICompute.providedBy(compute.__parent__.__parent__): log.msg('Inconsistent data: %s, Compute is expected. Attempting to fix %s' % (compute.__parent__.__parent__, compute), system='sync-vms', logLevel=logging.WARNING) compute.__parent__ = self.context log.msg('Fixing %s %s' % (compute, 'successful!' if ICompute.providedBy(compute.__parent__.__parent__) else 'failed!'), system='sync-vms', logLevel=logging.WARNING) if not ICompute.providedBy(compute.__parent__.__parent__): return action = SyncAction(compute) matching = [rvm for rvm in remote_vms if rvm['uuid'] == compute.__name__] if not matching: continue remote_vm = matching[0] # todo delegate all this into the action itself default_console = action._default_console() action._sync_consoles() action.sync_owner_transact(remote_vm) action.sync_vm(remote_vm) action.create_default_console(default_console)
def handle(self, event): factory = event.element.factory if factory: factory._handle(event) else: component.handle(event)
def _after_handler(self, new_item): if self.properties('reset-tool-after-create', False): self.action_group.get_action('toolbox-pointer').activate() component.handle(DiagramItemCreateEvent(new_item))
def redispatch(event): handle(event.obj, event)
def redispatch(event): handle(event.context, event)
def setup_environ(test=False): grok_all() handle(BeforeApplicationInitalizedEvent(test=test)) handle(ApplicationInitalizedEvent(test=test))
def _handle(self, event): """ Handle events coming from elements. """ # Invoke default handler, so properties get updated. component.handle(event)