def test_actor_may_be_unregistered_multiple_times_without_error(self): ActorRegistry.unregister(self.ref) self.assert_(self.ref not in ActorRegistry.get_all()) ActorRegistry.unregister(self.ref) self.assert_(self.ref not in ActorRegistry.get_all()) ActorRegistry.register(self.ref) self.assert_(self.ref in ActorRegistry.get_all())
def start(cls, *args, **kwargs): """ Start an actor and register it in the :class:`pykka.registry.ActorRegistry`. Any arguments passed to :meth:`start` will be passed on to the class constructor. Returns a :class:`ActorRef` which can be used to access the actor in a safe manner. Behind the scenes, the following is happening when you call :meth:`start`:: Actor.start() Actor.__new__() superclass.__new__() superclass.__init__() URN assignment Inbox creation ActorRef creation Actor.__init__() # Your code can run here ActorRegistry.register() superclass.start() """ obj = cls(*args, **kwargs) _ActorRegistry.register(obj.actor_ref) cls._superclass.start(obj) _logger.debug('Started %s', obj) return obj.actor_ref
def start(cls, *args, **kwargs): """ Start an actor and register it in the :class:`ActorRegistry <pykka.registry.ActorRegistry>`. Any arguments passed to :meth:`start` will be passed on to the class constructor. Returns a :class:`ActorRef` which can be used to access the actor in a safe manner. Behind the scenes, the following is happening when you call :meth:`start`:: Actor.start() Actor.__new__() superclass.__new__() superclass.__init__() URN assignment Inbox creation ActorRef creation Actor.__init__() # Your code can run here ActorRegistry.register() superclass.start() """ obj = cls(*args, **kwargs) _ActorRegistry.register(obj.actor_ref) cls._superclass.start(obj) _logger.debug('Started %s', obj) return obj.actor_ref
def start(cls, *args, **kwargs): """ Start an actor and register it in the :class:`ActorRegistry <pykka.ActorRegistry>`. Any arguments passed to :meth:`start` will be passed on to the class constructor. Behind the scenes, the following is happening when you call :meth:`start`: 1. The actor is created: 1. :attr:`actor_urn` is initialized with the assigned URN. 2. :attr:`actor_inbox` is initialized with a new actor inbox. 3. :attr:`actor_ref` is initialized with a :class:`pykka.ActorRef` object for safely communicating with the actor. 4. At this point, your :meth:`__init__()` code can run. 2. The actor is registered in :class:`pykka.ActorRegistry`. 3. The actor receive loop is started by the actor's associated thread/greenlet. :returns: a :class:`ActorRef` which can be used to access the actor in a safe manner """ obj = cls(*args, **kwargs) assert obj.actor_ref is not None, ( 'Actor.__init__() have not been called. ' 'Did you forget to call super() in your override?') _ActorRegistry.register(obj.actor_ref) _logger.debug('Starting %s', obj) # pylint: disable = W0212 obj._start_actor_loop() # pylint: enable = W0212 return obj.actor_ref
def test_actor_may_be_registered_manually(self): ActorRegistry.unregister(self.ref) self.assert_(self.ref not in ActorRegistry.get_all()) ActorRegistry.register(self.ref) self.assert_(self.ref in ActorRegistry.get_all())