abstract registration functions into a protocol (#75)

motivation: allow frameworks that want to expose the lifecycle so that their downstream dependencies could register additional items

changes: abstract registration functions into a protocol and conform ComponentLifecycle and ServiceLifecycle to it

Author: tomerd

Sources/Lifecycle/Lifecycle.swift

@@ -81,6 +81,8 @@ public struct LifecycleHandler {
 
 // MARK: - ServiceLifecycle
 
+/// `ServiceLifecycle` provides a basic mechanism to cleanly startup and shutdown the application, freeing resources in order before exiting.
+///  By default, also install shutdown hooks based on `Signal` and backtraces.
 public struct ServiceLifecycle {
     private let configuration: Configuration
 
@@ -194,41 +196,10 @@ extension ServiceLifecycle {
     }
 }
 
-public extension ServiceLifecycle {
-    /// Adds a `LifecycleTask` to a `LifecycleTasks` collection.
-    ///
-    /// - parameters:
-    ///    - tasks: one or more `LifecycleTask`.
-    func register(_ tasks: LifecycleTask ...) {
-        self.underlying.register(tasks)
-    }
-
-    /// Adds a `LifecycleTask` to a `LifecycleTasks` collection.
-    ///
-    /// - parameters:
-    ///    - tasks: array of `LifecycleTask`.
-    func register(_ tasks: [LifecycleTask]) {
+extension ServiceLifecycle: LifecycleTasksContainer {
+    public func register(_ tasks: [LifecycleTask]) {
         self.underlying.register(tasks)
     }
-
-    /// Adds a `LifecycleTask` to a `LifecycleTasks` collection.
-    ///
-    /// - parameters:
-    ///    - label: label of the item, useful for debugging.
-    ///    - start: `LifecycleHandler` to perform the startup.
-    ///    - shutdown: `LifecycleHandler` to perform the shutdown.
-    func register(label: String, start: LifecycleHandler, shutdown: LifecycleHandler) {
-        self.underlying.register(label: label, start: start, shutdown: shutdown)
-    }
-
-    /// Adds a `LifecycleTask` to a `LifecycleTasks` collection.
-    ///
-    /// - parameters:
-    ///    - label: label of the item, useful for debugging.
-    ///    - handler: `LifecycleHandler` to perform the shutdown.
-    func registerShutdown(label: String, _ handler: LifecycleHandler) {
-        self.underlying.registerShutdown(label: label, handler)
-    }
 }
 
 extension ServiceLifecycle {
@@ -265,7 +236,7 @@ struct ShutdownError: Error {
 
 // MARK: - ComponentLifecycle
 
-/// `Lifecycle` provides a basic mechanism to cleanly startup and shutdown the application, freeing resources in order before exiting.
+/// `ComponentLifecycle` provides a basic mechanism to cleanly startup and shutdown a subsystem in a larger application, freeing resources in order before exiting.
 public class ComponentLifecycle: LifecycleTask {
     public let label: String
     private let logger: Logger
@@ -480,42 +451,35 @@ public class ComponentLifecycle: LifecycleTask {
     }
 }
 
-public extension ComponentLifecycle {
-    internal struct Task: LifecycleTask {
-        let label: String
-        let start: LifecycleHandler
-        let shutdown: LifecycleHandler
-
-        func start(_ callback: @escaping (Error?) -> Void) {
-            self.start.run(callback)
+extension ComponentLifecycle: LifecycleTasksContainer {
+    public func register(_ tasks: [LifecycleTask]) {
+        self.stateLock.withLock {
+            guard case .idle = self.state else {
+                preconditionFailure("invalid state, \(self.state)")
+            }
         }
-
-        func shutdown(_ callback: @escaping (Error?) -> Void) {
-            self.shutdown.run(callback)
+        self.tasksLock.withLock {
+            self.tasks.append(contentsOf: tasks)
         }
     }
+}
 
+/// A container of `LifecycleTask`, used to register additional `LifecycleTask`
+public protocol LifecycleTasksContainer {
     /// Adds a `LifecycleTask` to a `LifecycleTasks` collection.
     ///
     /// - parameters:
-    ///    - tasks: one or more `LifecycleTask`.
-    func register(_ tasks: LifecycleTask ...) {
-        self.register(tasks)
-    }
+    ///    - tasks: array of `LifecycleTask`.
+    func register(_ tasks: [LifecycleTask])
+}
 
+extension LifecycleTasksContainer {
     /// Adds a `LifecycleTask` to a `LifecycleTasks` collection.
     ///
     /// - parameters:
-    ///    - tasks: array of `LifecycleTask`.
-    func register(_ tasks: [LifecycleTask]) {
-        self.stateLock.withLock {
-            guard case .idle = self.state else {
-                preconditionFailure("invalid state, \(self.state)")
-            }
-        }
-        self.tasksLock.withLock {
-            self.tasks.append(contentsOf: tasks)
-        }
+    ///    - tasks: one or more `LifecycleTask`.
+    public func register(_ tasks: LifecycleTask ...) {
+        self.register(tasks)
     }
 
     /// Adds a `LifecycleTask` to a `LifecycleTasks` collection.
@@ -524,16 +488,30 @@ public extension ComponentLifecycle {
     ///    - label: label of the item, useful for debugging.
     ///    - start: `Handler` to perform the startup.
     ///    - shutdown: `Handler` to perform the shutdown.
-    func register(label: String, start: LifecycleHandler, shutdown: LifecycleHandler) {
-        self.register(Task(label: label, start: start, shutdown: shutdown))
+    public func register(label: String, start: LifecycleHandler, shutdown: LifecycleHandler) {
+        self.register(_LifecycleTask(label: label, start: start, shutdown: shutdown))
     }
 
     /// Adds a `LifecycleTask` to a `LifecycleTasks` collection.
     ///
     /// - parameters:
     ///    - label: label of the item, useful for debugging.
     ///    - handler: `Handler` to perform the shutdown.
-    func registerShutdown(label: String, _ handler: LifecycleHandler) {
+    public func registerShutdown(label: String, _ handler: LifecycleHandler) {
         self.register(label: label, start: .none, shutdown: handler)
     }
 }
+
+internal struct _LifecycleTask: LifecycleTask {
+    let label: String
+    let start: LifecycleHandler
+    let shutdown: LifecycleHandler
+
+    func start(_ callback: @escaping (Error?) -> Void) {
+        self.start.run(callback)
+    }
+
+    func shutdown(_ callback: @escaping (Error?) -> Void) {
+        self.shutdown.run(callback)
+    }
+}

Tests/LifecycleTests/ComponentLifecycleTests.swift

@@ -43,16 +43,16 @@ final class ComponentLifecycleTests: XCTestCase {
 
         let items = (1 ... Int.random(in: 10 ... 20)).map { index -> LifecycleTask in
             let id = "item-\(index)"
-            return ComponentLifecycle.Task(label: id,
-                                           start: .sync {
-                                               dispatchPrecondition(condition: .onQueue(.global()))
-                                               startCalls.append(id)
-                                           },
-                                           shutdown: .sync {
-                                               dispatchPrecondition(condition: .onQueue(.global()))
-                                               XCTAssertTrue(startCalls.contains(id))
-                                               stopCalls.append(id)
-                                           })
+            return _LifecycleTask(label: id,
+                                  start: .sync {
+                                      dispatchPrecondition(condition: .onQueue(.global()))
+                                      startCalls.append(id)
+                                  },
+                                  shutdown: .sync {
+                                      dispatchPrecondition(condition: .onQueue(.global()))
+                                      XCTAssertTrue(startCalls.contains(id))
+                                      stopCalls.append(id)
+                                 })
         }
         lifecycle.register(items)
 
@@ -81,16 +81,16 @@ final class ComponentLifecycleTests: XCTestCase {
 
         let items = (1 ... Int.random(in: 10 ... 20)).map { index -> LifecycleTask in
             let id = "item-\(index)"
-            return ComponentLifecycle.Task(label: id,
-                                           start: .sync {
-                                               dispatchPrecondition(condition: .onQueue(testQueue))
-                                               startCalls.append(id)
-                                           },
-                                           shutdown: .sync {
-                                               dispatchPrecondition(condition: .onQueue(testQueue))
-                                               XCTAssertTrue(startCalls.contains(id))
-                                               stopCalls.append(id)
-                                           })
+            return _LifecycleTask(label: id,
+                                  start: .sync {
+                                      dispatchPrecondition(condition: .onQueue(testQueue))
+                                      startCalls.append(id)
+                                  },
+                                  shutdown: .sync {
+                                      dispatchPrecondition(condition: .onQueue(testQueue))
+                                      XCTAssertTrue(startCalls.contains(id))
+                                      stopCalls.append(id)
+                                 })
         }
         lifecycle.register(items)