fixup

Co-authored-by: Yim Lee <[email protected]>

Author: tomerd

README.md

@@ -214,6 +214,32 @@ In more complex cases, when `Signal`-trapping-based shutdown is not appropriate,
 
 `shutdown` is an asynchronous operation. Errors will be logged and bubbled up to the provided completion handler.
 
+### Stateful handlers
+
+In some cases it is useful to have the Start handlers return a state that can be passed on to the Shutdown handlers for shutdown.
+For example, when establishing some sort of a connection that needs to be closed at shutdown.
+
+```swift
+struct Foo {
+  func start() throws -> Connection {
+      return ...
+  }
+
+  func shutdown(state: Connection) throws {
+      ...
+  }
+}
+```
+
+```swift
+let foo = ...
+lifecycle.registerStateful(
+    label: "foo",
+    start: .sync(foo.start),
+    shutdown: .sync(foo.shutdown)
+)
+```
+
 ### Complex Systems and Nesting of Subsystems
 
 In larger Applications (Services) `ComponentLifecycle` can be used to manage the lifecycle of subsystems, such that `ServiceLifecycle` can start and shutdown `ComponentLifecycle`s.

Sources/Lifecycle/Lifecycle.swift

@@ -41,26 +41,24 @@ extension LifecycleTask {
 
 /// Supported startup and shutdown method styles
 public struct LifecycleHandler {
-    @available(*, deprecated, renamed: "Handler")
+    @available(*, deprecated)
     public typealias Callback = (@escaping (Error?) -> Void) -> Void
 
-    public typealias Handler = (@escaping (Error?) -> Void) -> Void
-
-    private let underlying: Handler?
+    private let underlying: ((@escaping (Error?) -> Void) -> Void)?
 
     /// Initialize a `LifecycleHandler` based on a completion handler.
     ///
     /// - parameters:
     ///    - handler: the underlying completion handler
-    public init(_ handler: Handler?) {
+    public init(_ handler: ((@escaping (Error?) -> Void) -> Void)?) {
         self.underlying = handler
     }
 
     /// Asynchronous `LifecycleHandler` based on a completion handler.
     ///
     /// - parameters:
     ///    - handler: the underlying async handler
-    public static func async(_ handler: @escaping Handler) -> LifecycleHandler {
+    public static func async(_ handler: @escaping (@escaping (Error?) -> Void) -> Void) -> LifecycleHandler {
         return LifecycleHandler(handler)
     }
 
@@ -100,27 +98,25 @@ public struct LifecycleHandler {
 
 /// LifecycleHandler for starting stateful tasks. The state can then be fed into a LifecycleShutdownHandler
 public struct LifecycleStartHandler<State> {
-    public typealias Handler = (@escaping (Result<State, Error>) -> Void) -> Void
-
-    private let underlying: Handler
+    private let underlying: (@escaping (Result<State, Error>) -> Void) -> Void
 
     /// Initialize a `LifecycleHandler` based on a completion handler.
     ///
     /// - parameters:
     ///    - callback: the underlying completion handler
-    public init(_ handler: @escaping Handler) {
+    public init(_ handler: @escaping (@escaping (Result<State, Error>) -> Void) -> Void) {
         self.underlying = handler
     }
 
     /// Asynchronous `LifecycleStartHandler` based on a completion handler.
     ///
     /// - parameters:
     ///    - handler: the underlying async handler
-    public static func async(_ handler: @escaping Handler) -> LifecycleStartHandler {
+    public static func async(_ handler: @escaping (@escaping (Result<State, Error>) -> Void) -> Void) -> LifecycleStartHandler {
         return LifecycleStartHandler(handler)
     }
 
-    /// Asynchronous `LifecycleStartHandler` based on a blocking, throwing function.
+    /// Synchronous `LifecycleStartHandler` based on a blocking, throwing function.
     ///
     /// - parameters:
     ///    - body: the underlying function
@@ -142,23 +138,21 @@ public struct LifecycleStartHandler<State> {
 
 /// LifecycleHandler for shutting down stateful tasks. The state comes from a LifecycleStartHandler
 public struct LifecycleShutdownHandler<State> {
-    public typealias Handler = (State, @escaping (Error?) -> Void) -> Void
-
-    private let underlying: Handler
+    private let underlying: (State, @escaping (Error?) -> Void) -> Void
 
     /// Initialize a `LifecycleShutdownHandler` based on a completion handler.
     ///
     /// - parameters:
     ///    - handler: the underlying completion handler
-    public init(_ handler: @escaping Handler) {
+    public init(_ handler: @escaping (State, @escaping (Error?) -> Void) -> Void) {
         self.underlying = handler
     }
 
     /// Asynchronous `LifecycleShutdownHandler` based on a completion handler.
     ///
     /// - parameters:
     ///    - handler: the underlying async handler
-    public static func async(_ handler: @escaping Handler) -> LifecycleShutdownHandler {
+    public static func async(_ handler: @escaping (State, @escaping (Error?) -> Void) -> Void) -> LifecycleShutdownHandler {
         return LifecycleShutdownHandler(handler)
     }
 
@@ -605,7 +599,7 @@ extension LifecycleTasksContainer {
         self.register(label: label, start: .none, shutdown: handler)
     }
 
-    /// Adds a  stateful `LifecycleTask` to a `LifecycleTasks` collection.
+    /// Add a stateful `LifecycleTask` to a `LifecycleTasks` collection.
     ///
     /// - parameters:
     ///    - label: label of the item, useful for debugging.
@@ -616,6 +610,7 @@ extension LifecycleTasksContainer {
     }
 }
 
+// internal for testing
 internal struct _LifecycleTask: LifecycleTask {
     let label: String
     let shutdownIfNotStarted: Bool
@@ -638,6 +633,7 @@ internal struct _LifecycleTask: LifecycleTask {
     }
 }
 
+// internal for testing
 internal class StatefulLifecycleTask<State>: LifecycleTask {
     let label: String
     let shutdownIfNotStarted: Bool = false