Actor state via messages

examples/actors/most_basic_supervisor.py

@@ -0,0 +1,86 @@
+import trio
+import tractor
+
+
+class Restart(Exception):
+    """Restart signal"""
+
+
+async def sleep_then_restart():
+    actor = tractor.current_actor()
+    print(f'{actor.uid} starting up!')
+    await trio.sleep(0.5)
+    raise Restart('This is a restart signal')
+
+
+async def signal_restart_whole_actor():
+    actor = tractor.current_actor()
+    print(f'{actor.uid} starting up!')
+    await trio.sleep(0.5)
+    return 'restart_me'
+
+
+async def respawn_remote_task(portal):
+    # start a task in the actor at the other end
+    # of the provided portal, when it signals a restart,
+    # restart it..
+
+    # This is much more efficient then restarting the undlerying
+    # process over and over since the python interpreter runtime
+    # stays up and we just submit a new task to run (which
+    # is just the original one we submitted repeatedly.
+    while True:
+        try:
+            await portal.run(sleep_then_restart)
+        except tractor.RemoteActorError as error:
+            if 'Restart' in str(error):
+                # respawn the actor task
+                continue
+
+
+async def supervisor():
+
+    async with tractor.open_nursery() as tn:
+
+        p0 = await tn.start_actor('task_restarter', enable_modules=[__name__])
+
+        # Yes, you can do this from multiple tasks on one actor
+        # or mulitple lone tasks in multiple subactors.
+        # We'll show both.
+
+        async with trio.open_nursery() as n:
+            # we'll doe the first as a lone task restart in a daemon actor
+            for i in range(4):
+                n.start_soon(respawn_remote_task, p0)
+
+            # Open another nursery that will respawn sub-actors
+
+            # spawn a set of subactors that will signal restart
+            # of the group of processes on each failures
+            portals = []
+
+            # start initial subactor set
+            for i in range(4):
+                p = await tn.run_in_actor(signal_restart_whole_actor)
+                portals.append(p)
+
+            # now wait on results and respawn actors
+            # that request it
+            while True:
+
+                for p in portals:
+                    result = await p.result()
+
+                    if result == 'restart_me':
+                        print(f'restarting {p.channel.uid}')
+                        await p.cancel_actor()
+                        await trio.sleep(0.5)
+                        p = await tn.run_in_actor(signal_restart_whole_actor)
+                        portals.append(p)
+
+    # this will block indefinitely so user must
+    # cancel with ctrl-c
+
+
+if __name__ == '__main__':
+    trio.run(supervisor)

examples/actors/mutate_remote_state.py

@@ -0,0 +1,64 @@
+from itertools import cycle
+from pprint import pformat
+from dataclasses import dataclass, field
+
+import trio
+import tractor
+
+
+@dataclass
+class MyProcessStateThing:
+    state: dict = field(default_factory=dict)
+
+    def update(self, msg: dict):
+        self.state.update(msg)
+
+
+_actor_state = MyProcessStateThing()
+
+
+async def update_local_state(msg: dict):
+    """Update process-local state from sent message and exit.
+
+    """
+    actor = tractor.current_actor()
+
+    global _actor_state
+
+
+    print(f'Yo we got a message {msg}')
+
+    # update the "actor state"
+    _actor_state.update(msg)
+
+    print(f'New local "state" for {actor.uid} is {pformat(_actor_state.state)}')
+
+    # we're done so exit this task running in the subactor
+
+
+async def main():
+    # Main process/thread that spawns one sub-actor and sends messages
+    # to it to update it's state.
+
+    actor_portals = []
+
+    # XXX: that subactor can **not** outlive it's parent, this is SC.
+    async with tractor.open_nursery() as tn:
+
+        portal = await tn.start_actor('even_boy', enable_modules=[__name__])
+        actor_portals.append(portal)
+
+        portal = await tn.start_actor('odd_boy', enable_modules=[__name__])
+        actor_portals.append(portal)
+
+        for i, (count, portal) in enumerate(
+            zip(range(100), cycle(actor_portals))
+        ):
+            await portal.run(update_local_state, msg={f'msg_{i}': count})
+
+    # blocks here indefinitely synce we spawned "daemon actors" using
+    # .start_actor()`, you'll need to control-c to cancel.
+
+
+if __name__ == '__main__':
+    trio.run(main)

examples/actors/ray_style_classes.py

@@ -0,0 +1,153 @@
+import inspect
+from typing import Any
+from functools import partial
+from contextlib import asynccontextmanager, AsyncExitStack
+from itertools import cycle
+from pprint import pformat
+
+import trio
+import tractor
+
+
+log = tractor.log.get_logger(__name__)
+
+
+class ActorState:
+    """Singlteton actor per process.
+
+    """
+    # this is a class defined variable and is thus both
+    # singleton across object instances and task safe.
+    state: dict = {}
+
+    def update(self, msg: dict) -> None:
+        _actor = tractor.current_actor()
+
+        print(f'Yo we got a message {msg}')
+        self.state.update(msg)
+
+        print(f'New local "state" for {_actor.uid} is {pformat(self.state)}')
+
+    def close(self):
+        # gives headers showing which process and task is active
+        log.info('Actor state is closing')
+
+    # if we wanted to support spawning or talking to other
+    # actors we can do that using a portal map collection?
+    # _portals: dict = {}
+
+
+async def _run_proxy_method(
+    meth: str,
+    msg: dict,
+) -> Any:
+    """Update process-local state from sent message and exit.
+
+    """
+    # Create a new actor instance per call.
+    # We can make this persistent by storing it either
+    # in a global var or are another clas scoped variable?
+    # If you want it somehow persisted in another namespace
+    # I'd be interested to know "where".
+    actor = ActorState()
+    if meth != 'close':
+        return getattr(actor, meth)(msg)
+    else:
+        actor.close()
+
+    # we're done so exit this task running in the subactor
+
+
+class MethodProxy:
+    def __init__(
+        self,
+        portal: tractor._portal.Portal
+    ) -> None:
+        self._portal = portal
+
+    async def _run_method(
+        self,
+        *,
+        meth: str,
+        msg: dict,
+    ) -> Any:
+        return await self._portal.run(
+            _run_proxy_method,
+            meth=meth,
+            msg=msg
+        )
+
+
+def get_method_proxy(portal, target=ActorState) -> MethodProxy:
+
+    proxy = MethodProxy(portal)
+
+    # mock all remote methods
+    for name, method in inspect.getmembers(
+        target, predicate=inspect.isfunction
+    ):
+        if '_' == name[0]:
+            # skip private methods
+            continue
+
+        else:
+            setattr(proxy, name, partial(proxy._run_method, meth=name))
+
+    return proxy
+
+
+@asynccontextmanager
+async def spawn_proxy_actor(name):
+
+    # XXX: that subactor can **not** outlive it's parent, this is SC.
+    async with tractor.open_nursery(
+        debug_mode=True,
+        # loglevel='info',
+    ) as tn:
+
+        portal = await tn.start_actor(name, enable_modules=[__name__])
+
+        proxy = get_method_proxy(portal)
+
+        yield proxy
+
+        await proxy.close(msg=None)
+
+
+async def main():
+    # Main process/thread that spawns one sub-actor and sends messages
+    # to it to update it's state.
+
+    try:
+        stack = AsyncExitStack()
+
+        actors = []
+        for name in ['even', 'odd']:
+
+            actor_proxy = await stack.enter_async_context(
+                    spawn_proxy_actor(name + '_boy')
+            )
+            actors.append(actor_proxy)
+
+        # spin through the actors and update their states
+        for i, (count, actor) in enumerate(
+            zip(range(100), cycle(actors))
+        ):
+            # Here we call the locally patched `.update()` method of the
+            # remote instance
+
+            # NOTE: the instance created each call here is currently
+            # a new object - to persist it across `portal.run()` calls
+            # we need to store it somewhere in memory for access by
+            # a new task spawned in the remote actor process.
+            await actor.update(msg={f'msg_{i}': count})
+
+    # blocks here indefinitely synce we spawned "daemon actors" using
+    # .start_actor()`, you'll need to control-c to cancel.
+
+    finally:
+        await stack.aclose()
+
+
+if __name__ == '__main__':
+    trio.run(main)