parley.proxy
parley/proxy.py - reference and communice with spawned actors.
parley.helpers
parley/helpers.py - helper classes and functions for constructing actors.
class RPCException(exceptions.Exception):
Indicates a generic failure during an RPC call.
class RemoteException(parley.RPCException):
This exception indicates that the remote actor responded to a message by sending an exception.
class StopActor(exceptions.Exception):
Raise this exception to cause an actor to terminate normally.
def link(target):
Create a bidirectional link to the target actor. If one linked actor terminates abnormally, the other will raise an AbnormalExit exception upon its next call to recv(). Similarly, if one actor terminates normally, a quit message will be sent to the other.
def lookup(name):
Return the actor proxy associated with the given name. Raises NoSuchActor if the name has not been registered.
def me():
Return a proxy object for the currently running actor.
def recv(msg_filter=None):
Return a waiting message for the current actor, or block (allowing other threads to continue) until a message is available. The optional msg_filter argument should accept a message as an argument and return True or False to determine whether to return the message or leave it for later. If any actor linked to the current actor terminates abnormally, this method will raise AbnormalExit instead of returning.
def recv_nowait(msg_filter=None):
Like recv, but returns None instead of blocking if no message is available. In the future, arbitrary timeouts will likely be supported.
def register(target, name):
Register the target actor proxy as being available under the given name.
def register_controller(controller):
Register a given actor controller object as the global actor controller. Normally, you will call start_tasklet_controller or start_thread_controller instead of this function; this function exists for those implementing some sort of alternative actor initialization scheme.
def schedule():
Allow another thread the chance to run. In an execution model that is already preemptive, this is a noop.
def set_name(name):
Set the internal name of the current actor. This is not any sort of globally reachable ID; this name is just to identify the actor for debugging purposes (e.g. if trace_on() has been called).
def spawn(actor, *args, **kwargs):
Spawn a new actor in a new thread of execution. This function returns an ActorProxy object that can be used to reference the spawned actor and communicate with it. As with the built-in "apply" function, the first argument can be any callable object, and remaining arguments are forwarded to that function.
def spawn_link(actor, *args, **kwargs):
Spawn a new actor and link the current actor to it. Equivalent to: a=spawn(...) link(a) but executed atomically: i.e., the spawned actor will not be started until it has been linked to the calling actor.
def start_tasklet_controller(entry_point, *args, **kwargs):
Start the tasklet controller and spawn the actor given by entry_point (forwarding args and kwargs to entry_point).
def start_thread_controller(entry_point, *args, **kwargs):
Start the thread controller and spawn the actor given by entry_point (forwarding args and kwargs to entry_point).
def trace_off():
Stop the tracing of sent messages.
def trace_on(out_file=<open file '<stdout>', mode 'w'>):
Cause sent messages to be printed to the specified file. If no file is specified, stdout is used.
def unlink(target):
Cancel the bidirectional link to the target actor.
def unregister(name):
Unregister the actor proxy associated with the given name.