Initial prototype for `trio.Nursery` per-task-scope-mangement via a user defined single-yield-generator function 😎 #363

goodboy · 2023-05-17T18:32:49Z

As per some discussion in the trio gitter and starting something
toward #22 and supporting our debugger crash mode from within
a trio-compat task nursery.

Idea: a `trio.Nursery` API for optionally allowing a user to define a per-task manager

But why?

Well if you wanted any of the following (some of which are implemented
in the module script in this patch):

generally gain access to lower level trio.Nursery "internals" for any
per-task oriented purpose.
some way to wrap your own "task handle" so you could do things like
waiting on a task to finish and get its result.
allow hooking into each task's exit/teardown (phase) for the purposes
of debugging crashes, (unexpected) cancels or just generally tracing
the trio per task control flow.
enable more granular task supervision strategies like one_for_one
from erlang/elixir and friends.

ToDo:

Hopefully much more to come!

goodboy · 2023-05-17T18:36:26Z

tractor/trionics/_supervisor.py

+        return self.result
+
+
+class TaskHandle(Struct):


TODO: show an second example where the cancel_scope_manager generator wraps the trio internals listed as attrs into this compound type and then that is what's returned from the .start_soon() call?

goodboy · 2023-05-17T18:40:33Z

tractor/trionics/_supervisor.py

+
+    scope_manager: ContextManager | None = None
+
+    async def start_soon(


I don't really know what the best API would be for doing this with .start()?

you don't really need start since you can always implement it by getting the child task to Event.set(), or even further use this MaybeOutcome thing from above.

how do you get the cancel_scope_manager yielded output in that case, since .start() would normally return whatever the child passed to status.started()?

i.e. you can't do started = await n.start(blah) and expect started to be the outcome, cs stuff

maybe the child task could get access to it's own cancel scope "stuff" from somewhere and then choose to status.started((outcome, cs)) it back to the caller?

Huh, i guess we could just offer some kinda support for hooking into the started value returned by the task? that way the cancel_scope_manager could decide what to send back to the .start() caller with the default being the value that the child .started() ?

huh, likely you could implement that as a double yield generator then?

I dunno what would be best for ensuring that other then decorator params and then async_fn checking inside .start() against that i guess?

goodboy · 2023-05-17T18:43:51Z

tractor/trionics/_supervisor.py

+
+            val: str = 'yoyoyo'
+            val_outcome, cs = await sn.start_soon(sleep_then_return_val, val)
+            res = await val_outcome.unwrap()


As already mentioned above in the comment on the method, probably a better name is warranted for this since you're actually first waiting for the outcome then unwrapping it's underlying value/result.

goodboy · 2023-05-17T18:45:26Z

tractor/trionics/_supervisor.py

+            assert res == val
+            print(f'GOT EXPECTED TASK VALUE: {res}')
+
+            print('WAITING FOR CRASH..')


scheduling sleep_then_err() results in an assertion error that is caught and handled in the pdbp REPL thanks to the cancel_scope_manager implementation which does this on std Exceptions 😎

Note, you could also catch trio.Cancelled or wtv else by changing the except line 🏄🏼

goodboy · 2023-05-17T18:57:48Z

tractor/trionics/_supervisor.py

+
+        async def _start_wrapped_in_scope(
+            task_status: TaskStatus[
+                tuple[CancelScope, Task]


wrong, this should be the type sig of whatever is yielded from the self.scope_manager obviously

goodboy · 2023-05-17T18:59:23Z

tractor/trionics/_supervisor.py

+
+        # TODO: better way to concat the values delivered by the user
+        # provided `.scope_manager` and the outcome?
+        return tuple([maybe_outcome] + to_return)


yeah as mentioned in the TODO, don't love this concat-ing of the results from the scope_manager(), but i think this goes away if we instead implement our own generator as @trio.cancel_scope_manager protocol since then the absolute value tuple yielded can be returned directly?

goodboy · 2023-05-19T17:41:12Z

tractor/trionics/_supervisor.py

+            # TODO: this was working before?!
+            # nonlocal to_return
+
+            with cs:


Ahh wait, right.. so we do need to activate this here or can it be done in the user's @task_scope_manager thing?

goodboy · 2023-05-19T17:41:48Z

tractor/trionics/_supervisor.py

+        # task = new_tasks.pop()
+
+        n: Nursery = self._n
+        cs = CancelScope()


Do we need this allocated here?
See comment(s) below.

…ng..

As was listed in the many todos, this changes the `.start_soon()` impl to instead (manually) `.send()` into the user defined `@task_scope_manager` an `Outcome` from the spawned task. In this case the task manager wraps that in a user defined (and renamed) `TaskOutcome` and delivers that + a containing `trio.CancelScope` to the `.start_soon()` caller. Here the user defined `TaskOutcome` defines a `.wait_for_result()` method that can be used to await the task's exit and handle it's underlying returned value or raised error; the implementation could be different and subject to the user's own whims. Note that by default, if this was added to `trio`'s core, the `@task_scope_manager` would simply be implemented as either a `None` yielding single-yield-generator but more likely just entirely ignored by the runtime (as in no manual task outcome collecting, generator calling and sending is done at all) by default if the user does not provide the `task_scope_manager` to the nursery at open time.

Turns out the nursery doesn't have to care about allocating a per task `CancelScope` since the user can just do that in the `@task_scope_manager` if desired B) So just mask all the nursery cs allocating with the intention of removal. Also add a test for per-task-cancellation by starting the crash task as a `trio.sleep_forever()` but then cancel it via the user allocated cs and ensure the crash propagates as expected 💥

- drop unneeded (and commented) internal cs allocating bits. - bypass all task manager stuff if no generator is provided by the caller; i.e. just call `.start_soon()` as normal. - fix `Generator` typing. - add some prints around task manager. - wrap in `TaskOutcome.lowlevel_task: Task`.

goodboy · 2023-05-19T18:35:41Z

tractor/trionics/_supervisor.py

+        return self.result
+
+
+class ScopePerTaskNursery(Struct):


Heh, guess we don't need much of a special name now?

PerTaskHookableNursery 😂

goodboy · 2023-05-19T18:36:34Z

tractor/trionics/_supervisor.py

+        *args,
+
+        name=None,
+        scope_manager: ContextManager | None = None,


maybe task_manager is a better name?

goodboy · 2023-05-19T18:40:19Z

tractor/trionics/_supervisor.py

+        name=None,
+        scope_manager: ContextManager | None = None,
+
+    ) -> tuple[CancelScope, Task]:


needs to again be dynamically defined at runtime.. soo use the ParamSpec stuff?

goodboy · 2023-05-19T19:32:49Z

tractor/trionics/_supervisor.py

+
+            await trio.sleep(0.6)
+            print(
+                'Cancelling and waiting on {err_outcome.lowlevel_task} '


lul, missing f-string

goodboy · 2023-05-19T19:34:59Z

tractor/trionics/_supervisor.py

+# TODO: define a decorator to runtime type check that this a generator
+# with a single yield that also delivers a value (of some std type) from
+# the yield expression?
+# @trio.task_scope_manager


maybe just @trio.task_manager ?

goodboy · 2023-05-19T19:38:23Z

tractor/trionics/_supervisor.py

+def add_task_handle_and_crash_handling(
+    nursery: Nursery,
+
+    # TODO: is this the only way we can have a per-task scope


no, we don't need the nursery to allocate any cancel scope per task interally!

need to remove this!

Allows dynamically importing `pdbp` when enabled and a way for eventually linking with `tractor`'s own debug mode flag.

goodboy commented May 17, 2023

View reviewed changes

goodboy added supervision trionics discussion experiment Exploratory design and testing labels May 17, 2023

goodboy force-pushed the oco_supervisor_prototype branch from bc2bd2d to a7af633 Compare May 19, 2023 17:31

goodboy commented May 19, 2023

View reviewed changes

goodboy force-pushed the oco_supervisor_prototype branch from e4d4434 to 6c089c0 Compare May 19, 2023 18:28

goodboy changed the title ~~Initial prototype for a one-cancels-one style supervisor, nursery thing?~~ Initial prototype for trio.Nursery per-task-scope-mangement via a user defined single-yield-generator function 😎 May 19, 2023

goodboy added 6 commits May 19, 2023 14:32

Initial prototype for a one-cancels-one style supervisor, nursery thi…

5fc8fa5

…ng..

Alias to @acm in broadcaster mod

b485871

Facepalm, don't pass in unecessary cancel scope

f23b5b8

goodboy force-pushed the oco_supervisor_prototype branch from 6c089c0 to 940e65f Compare May 19, 2023 18:32

goodboy commented May 19, 2023

View reviewed changes

goodboy force-pushed the oco_supervisor_prototype branch 2 times, most recently from cda85a3 to b24f0d5 Compare May 19, 2023 19:33

goodboy commented May 19, 2023

View reviewed changes

goodboy force-pushed the oco_supervisor_prototype branch 3 times, most recently from aed71dc to 0025e09 Compare May 19, 2023 19:43

Go all in on "task manager" naming

e0c888f

goodboy force-pushed the oco_supervisor_prototype branch from 0025e09 to e0c888f Compare May 19, 2023 19:44

Add debug_mode: bool control to task mngr

c7e27ad

Allows dynamically importing `pdbp` when enabled and a way for eventually linking with `tractor`'s own debug mode flag.

goodboy force-pushed the oco_supervisor_prototype branch from 872dcd7 to c7e27ad Compare May 19, 2023 19:53

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Initial prototype for `trio.Nursery` per-task-scope-mangement via a user defined single-yield-generator function 😎 #363

Initial prototype for `trio.Nursery` per-task-scope-mangement via a user defined single-yield-generator function 😎 #363

goodboy commented May 17, 2023 •

edited

Loading

goodboy May 17, 2023 •

edited

Loading

goodboy May 17, 2023

goodboy May 17, 2023

goodboy May 17, 2023

goodboy May 17, 2023

goodboy May 17, 2023

goodboy May 17, 2023

goodboy May 17, 2023

goodboy May 19, 2023

goodboy May 19, 2023

goodboy May 19, 2023

goodboy May 19, 2023

goodboy May 19, 2023 •

edited

Loading

goodboy May 19, 2023

goodboy May 19, 2023

goodboy May 19, 2023


		scope_manager: ContextManager \| None = None

		async def start_soon(

Initial prototype for trio.Nursery per-task-scope-mangement via a user defined single-yield-generator function 😎 #363

Are you sure you want to change the base?

Initial prototype for trio.Nursery per-task-scope-mangement via a user defined single-yield-generator function 😎 #363

Conversation

goodboy commented May 17, 2023 • edited Loading

Idea: a trio.Nursery API for optionally allowing a user to define a per-task manager

ToDo:

goodboy May 17, 2023 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

goodboy May 19, 2023 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Initial prototype for `trio.Nursery` per-task-scope-mangement via a user defined single-yield-generator function 😎 #363

Initial prototype for `trio.Nursery` per-task-scope-mangement via a user defined single-yield-generator function 😎 #363

goodboy commented May 17, 2023 •

edited

Loading

Idea: a `trio.Nursery` API for optionally allowing a user to define a per-task manager

goodboy May 17, 2023 •

edited

Loading

goodboy May 19, 2023 •

edited

Loading