jypma opened a new pull request, #1802: URL: https://github.com/apache/pekko/pull/1802
Relates to #1801 This commit introduces `Task`, a data structure that represents a recipe, or program, for producing a value of type T (or failing with an exception). It is similar in semantics to `RunnableGraph[T]`, but intended as first-class building block. It has the following properties: - A task can have resources associated to it, which are guaranteed to be released if the task is cancelled or fails - Tasks can be forked so multiple ones can run concurrently - Such forked tasks can be cancelled A Task can be created from a `RunnableGraph` which has a `KillSwitch`, by connecting a `Source` and a `Sink` through a `KillSwitch`, or by direct lambda functions. ### Open discussion points and TODOs (in order of highest architectural impact): - [X] Current cancellation of a graph through `KillSwitch` doesn't communicate back a trigger when the graph is actually done cancelling. However, since we also have the `Future[T]` that the graph's sink materializes to, that's enough to synchronize on. - [X] Resource safety, which can then guarantee cleanup even under cancellation signals. - [X] Background processing wth cancellation (fibers, `forkDaemon`, `forkResource`). No child fibers (yet). - [X] Add many more combinators (plain `zip`, `andThen`, `before`, `raceAll`) - [x] Add more combinators (`asResource`, ...) - [x] Add `.delay()` and general scheduling by hooking in the scheduling features of `Materializer` - [x] `Sink.forEachTask` and `Flow.mapTask` - [x] `Resource.ofAutoCloseable` - [x] `Task.never()` - [ ] `Task.runAsMain` (or perhaps `Application` base classes / traits), which runs a task as `main()`, capturing Ctrl+C to interrupt the task (and, hence, clean up resources). - [ ] Move to `task` module. Don't depend on `stream`. Streams should depend on `task`, so we can use tasks directly in stream combinators. - [ ] Scala DSL ### Needing an eye from reviewers: - [ ] More test cases to exercise typical edge cases and concurrency race conditions ### To be handled in later pull requests: - `TestClock` (implementation of `Clock` for unit tests, where tests can advance the clock, so time-driven code can run deterministically and faster than realtime) - Fun `Task`-friendly concurrency primitives like a queue, mutex, and a mutable ref with stream subscription support. - (Potentially) Another monad `Effect[E,A]` which introduces modelled errors (in addition to exceptions). This can be easily built on top of a `TaskDef[Either[E,A]]`. Fixes #1801 . -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: notifications-unsubscr...@pekko.apache.org For queries about this service, please contact Infrastructure at: us...@infra.apache.org --------------------------------------------------------------------- To unsubscribe, e-mail: notifications-unsubscr...@pekko.apache.org For additional commands, e-mail: notifications-h...@pekko.apache.org
