refactor "append" api (#3)

motivation: simplify registering items based on closures

changes:
* rename append to register
* introduce a Handler object that is an enum of sorts for types of startup and shutdown handler signature we support
* refactor tests to use the new code

Author: tomerd

Package.swift

@@ -15,6 +15,7 @@ let package = Package(
     ],
     targets: [
         .target(name: "Lifecycle", dependencies: ["Logging", "Metrics", "Backtrace"]),
-        .testTarget(name: "LifecycleTests", dependencies: ["Lifecycle", "NIO"]),
+        .target(name: "LifecycleNIOCompat", dependencies: ["Lifecycle", "NIO"]),
+        .testTarget(name: "LifecycleTests", dependencies: ["Lifecycle", "LifecycleNIOCompat"]),
     ]
 )

README.md

@@ -11,18 +11,17 @@ SwiftServiceLauncher is non-framework specific, designed to be integrated with a
 var lifecycle = Lifecycle()
 
 let eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: System.coreCount)
-lifecycle.append(
+lifecycle.registerShutdown(
     name: "eventLoopGroup",
-    shutdown: eventLoopGroup.syncShutdownGracefully
+    eventLoopGroup.syncShutdownGracefully
 )
 
 let httpClient = HTTPClient(eventLoopGroupProvider: .shared(eventLoopGroup))
-lifecycle.append(
+lifecycle.registerShutdown(
     name: "HTTPClient",
-    shutdown: httpClient.shutdown
+    httpClient.syncShutdown
 )
 
-
 lifecycle.start() { error in
     if let error = error {
         logger.error("failed starting \(self) ☠️: \(error)")

Sources/Lifecycle/Lifecycle.swift

@@ -212,98 +212,16 @@ public class Lifecycle {
 
 extension Lifecycle {
     internal struct Item: LifecycleItem {
-        public let name: String
-        private let _start: FunctionWithCallback?
-        private let _shutdown: FunctionWithCallback
-
-        init(name: String, start: FunctionWithCallback?, shutdown: @escaping FunctionWithCallback) {
-            self.name = name
-            self._start = start
-            self._shutdown = shutdown
-        }
-
-        init(name: String, start: FunctionWithCallback?, shutdown: @escaping ThrowingFunction) {
-            self.name = name
-            self._start = start
-            self._shutdown = Item.callback(shutdown)
-        }
-
-        init<Future, Value>(name: String, start: FunctionWithCallback?, shutdown: @escaping FutureProvider<Future, Value>) {
-            self.name = name
-            self._start = start
-            self._shutdown = Item.callback(shutdown)
-        }
-
-        init(name: String, start: ThrowingFunction?, shutdown: @escaping FunctionWithCallback) {
-            self.name = name
-            self._start = start.map(Item.callback)
-            self._shutdown = shutdown
-        }
-
-        init(name: String, start: ThrowingFunction?, shutdown: @escaping ThrowingFunction) {
-            self.name = name
-            self._start = start.map(Item.callback)
-            self._shutdown = Item.callback(shutdown)
-        }
-
-        init<Future, Value>(name: String, start: ThrowingFunction?, shutdown: @escaping FutureProvider<Future, Value>) {
-            self.name = name
-            self._start = start.map(Item.callback)
-            self._shutdown = Item.callback(shutdown)
-        }
-
-        init<Future, Value>(name: String, start: FutureProvider<Future, Value>?, shutdown: @escaping FunctionWithCallback) {
-            self.name = name
-            self._start = start.map(Item.callback)
-            self._shutdown = shutdown
-        }
-
-        init<Future, Value>(name: String, start: FutureProvider<Future, Value>?, shutdown: @escaping ThrowingFunction) {
-            self.name = name
-            self._start = start.map(Item.callback)
-            self._shutdown = Item.callback(shutdown)
-        }
-
-        init<Future, Value>(name: String, start: FutureProvider<Future, Value>?, shutdown: @escaping FutureProvider<Future, Value>) {
-            self.name = name
-            self._start = start.map(Item.callback)
-            self._shutdown = Item.callback(shutdown)
-        }
+        let name: String
+        let start: Handler
+        let shutdown: Handler
 
         func start(callback: @escaping (Error?) -> Void) {
-            if let body = self._start {
-                body(callback)
-            } else {
-                callback(nil)
-            }
+            self.start.run(callback)
         }
 
         func shutdown(callback: @escaping (Error?) -> Void) {
-            self._shutdown(callback)
-        }
-
-        private static func callback(_ body: @escaping ThrowingFunction) -> FunctionWithCallback {
-            return { callback in
-                do {
-                    try body()
-                    callback(nil)
-                } catch {
-                    callback(error)
-                }
-            }
-        }
-
-        private static func callback<Future, Value>(_ future: @escaping FutureProvider<Future, Value>) -> FunctionWithCallback {
-            return { callback in
-                future().whenComplete { result in
-                    switch result {
-                    case .success:
-                        callback(nil)
-                    case .failure(let error):
-                        callback(error)
-                    }
-                }
-            }
+            self.shutdown.run(callback)
         }
     }
 }
@@ -334,23 +252,23 @@ public extension Lifecycle {
     ///
     /// - parameters:
     ///    - items: one or more `LifecycleItem`.
-    internal func append(_ items: LifecycleItem...) {
+    func register(_ items: [LifecycleItem]) {
         self.stateSemaphore.lock {
             guard case .idle = self.state else {
                 preconditionFailure("invalid state, \(self.state)")
             }
         }
         self.itemsSemaphore.lock {
-            items.forEach { self.items.append($0) }
+            self.items.append(contentsOf: items)
         }
     }
 
     /// Adds a `LifecycleItem` to a `LifecycleItems` collection.
     ///
     /// - parameters:
     ///    - items: one or more `LifecycleItem`.
-    func append(_ items: [LifecycleItem]) {
-        items.forEach { self.append($0) }
+    internal func register(_ items: LifecycleItem...) {
+        self.register(items)
     }
 
     /// Add a `LifecycleItem` to a `LifecycleItems` collection.
@@ -359,128 +277,86 @@ public extension Lifecycle {
     ///    - name: name of the item, useful for debugging.
     ///    - start: closure to perform the startup.
     ///    - shutdown: closure to perform the shutdown.
-    func append(name: String, start: @escaping FunctionWithCallback, shutdown: @escaping FunctionWithCallback) {
-        self.append(Item(name: name, start: start, shutdown: shutdown))
-    }
-
-    /// Adds a `LifecycleItem` to a `LifecycleItems` collection.
-    ///
-    /// - parameters:
-    ///    - name: name of the item, useful for debugging.
-    ///    - shutdown: closure to perform the shutdown.
-    func append(name: String, shutdown: @escaping FunctionWithCallback) {
-        self.append(Item(name: name, start: nil as FunctionWithCallback?, shutdown: shutdown))
-    }
-
-    /// Adds a `LifecycleItem` to a `LifecycleItems` collection.
-    ///
-    /// - parameters:
-    ///    - name: name of the item, useful for debugging.
-    ///    - start: closure to perform the startup.
-    ///    - shutdown: closure to perform the shutdown.
-    func append(name: String, start: @escaping FunctionWithCallback, shutdown: @escaping ThrowingFunction) {
-        self.append(Item(name: name, start: start, shutdown: shutdown))
-    }
-
-    /// Adds a `LifecycleItem` to a `LifecycleItems` collection.
-    ///
-    /// - parameters:
-    ///    - name: name of the item, useful for debugging.
-    ///    - shutdown: closure to perform the shutdown.
-    func append(name: String, shutdown: @escaping ThrowingFunction) {
-        self.append(Item(name: name, start: nil as ThrowingFunction?, shutdown: shutdown))
+    func register(name: String, start: Handler, shutdown: Handler) {
+        self.register(Item(name: name, start: start, shutdown: shutdown))
     }
 
     /// Adds a `LifecycleItem` to a `LifecycleItems` collection.
     ///
     /// - parameters:
     ///    - name: name of the item, useful for debugging.
-    ///    - start: closure to perform the startup.
     ///    - shutdown: closure to perform the shutdown.
-    func append<Future, Value>(name: String, start: @escaping FunctionWithCallback, shutdown: @escaping FutureProvider<Future, Value>) {
-        self.append(Item(name: name, start: start, shutdown: shutdown))
+    func registerShutdown(name: String, _ handler: Handler) {
+        self.register(name: name, start: .none, shutdown: handler)
     }
 
     /// Adds a `LifecycleItem` to a `LifecycleItems` collection.
     ///
     /// - parameters:
     ///    - name: name of the item, useful for debugging.
+    ///    - start: closure to perform the shutdown.
     ///    - shutdown: closure to perform the shutdown.
-    func append<Future, Value>(name: String, shutdown: @escaping FutureProvider<Future, Value>) {
-        self.append(Item(name: name, start: nil as FutureProvider<Future, Value>?, shutdown: shutdown))
+    func register(name: String, start: @escaping () throws -> Void, shutdown: @escaping () throws -> Void) {
+        self.register(name: name, start: .sync(start), shutdown: .sync(shutdown))
     }
 
     /// Adds a `LifecycleItem` to a `LifecycleItems` collection.
     ///
     /// - parameters:
     ///    - name: name of the item, useful for debugging.
-    ///    - start: closure to perform the startup.
     ///    - shutdown: closure to perform the shutdown.
-    func append(name: String, start: @escaping ThrowingFunction, shutdown: @escaping FunctionWithCallback) {
-        self.append(Item(name: name, start: start, shutdown: shutdown))
-    }
-
-    /// Adds a `LifecycleItem` to a `LifecycleItems` collection.
-    ///
-    /// - parameters:
-    ///    - name: name of the item, useful for debugging.
-    ///    - shutdown: closure to perform the shutdown.
-    func append(name: String, start: @escaping ThrowingFunction, shutdown: @escaping ThrowingFunction) {
-        self.append(Item(name: name, start: start, shutdown: shutdown))
-    }
-
-    /// Adds a `LifecycleItem` to a `LifecycleItems` collection.
-    ///
-    /// - parameters:
-    ///    - name: name of the item, useful for debugging.
-    ///    - start: closure to perform the startup.
-    ///    - shutdown: closure to perform the shutdown.
-    func append<Future, Value>(name: String, start: @escaping ThrowingFunction, shutdown: @escaping FutureProvider<Future, Value>) {
-        self.append(Item(name: name, start: start, shutdown: shutdown))
-    }
-
-    /// Adds a `LifecycleItem` to a `LifecycleItems` collection.
-    ///
-    /// - parameters:
-    ///    - name: name of the item, useful for debugging.
-    ///    - shutdown: closure to perform the shutdown.
-    func append<Future, Value>(name: String, start: @escaping FutureProvider<Future, Value>, shutdown: @escaping FunctionWithCallback) {
-        self.append(Item(name: name, start: start, shutdown: shutdown))
-    }
-
-    /// Add a `LifecycleItem` to a `LifecycleItems` collection.
-    ///
-    /// - parameters:
-    ///    - name: name of the item, useful for debugging.
-    ///    - start: closure to perform the startup.
-    ///    - shutdown: closure to perform the shutdown.
-    func append<Future, Value>(name: String, start: @escaping FutureProvider<Future, Value>, shutdown: @escaping ThrowingFunction) {
-        self.append(Item(name: name, start: start, shutdown: shutdown))
-    }
-
-    /// Adds a `LifecycleItem` to a `LifecycleItems` collection.
-    ///
-    /// - parameters:
-    ///    - name: name of the item, useful for debugging.
-    ///    - start: closure to perform the startup.
-    ///    - shutdown: closure to perform the shutdown.
-    func append<Future, Value>(name: String, start: @escaping FutureProvider<Future, Value>, shutdown: @escaping FutureProvider<Future, Value>) {
-        self.append(Item(name: name, start: start, shutdown: shutdown))
+    func registerShutdown(name: String, _ handler: @escaping () throws -> Void) {
+        self.register(name: name, start: .none, shutdown: .sync(handler))
     }
 }
 
 /// Supported startup and shutdown method styles
-
 public extension Lifecycle {
-    typealias FunctionWithCallback = (@escaping (Error?) -> Void) -> Void
-    typealias ThrowingFunction = () throws -> Void
-    typealias FutureProvider<Future: LifecycleFuture, Value> = () -> Future where Future.Value == Value
-}
+    struct Handler {
+        private let body: (@escaping (Error?) -> Void) -> Void
+
+        /// Initialize a `Lifecycle.Handler` based on a completion handler.
+        ///
+        /// - parameters:
+        ///    - callback: the underlying completion handler
+        public init(_ callback: @escaping (@escaping (Error?) -> Void) -> Void) {
+            self.body = callback
+        }
 
-public protocol LifecycleFuture {
-    associatedtype Value
+        /// Asynchronous `Lifecycle.Handler` based on a completion handler.
+        ///
+        /// - parameters:
+        ///    - callback: the underlying completion handler
+        public static func async(_ callback: @escaping (@escaping (Error?) -> Void) -> Void) -> Handler {
+            return Handler(callback)
+        }
 
-    func whenComplete(_ callback: @escaping (Result<Value, Error>) -> Void)
+        /// Asynchronous `Lifecycle.Handler` based on a blocking, throwing function.
+        ///
+        /// - parameters:
+        ///    - body: the underlying function
+        public static func sync(_ body: @escaping () throws -> Void) -> Handler {
+            return Handler { completionHandler in
+                do {
+                    try body()
+                    completionHandler(nil)
+                } catch {
+                    completionHandler(error)
+                }
+            }
+        }
+
+        /// Noop `Lifecycle.Handler`.
+        public static var none: Handler {
+            return Handler { callback in
+                callback(nil)
+            }
+        }
+
+        internal func run(_ callback: @escaping (Error?) -> Void) {
+            self.body(callback)
+        }
+    }
 }
 
 /// Represents an item that can be started and shut down

Sources/LifecycleNIOCompat/Bridge.swift

@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the SwiftServiceLauncher open source project
+//
+// Copyright (c) 2019-2020 Apple Inc. and the SwiftServiceLauncher project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of SwiftServiceLauncher project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import Lifecycle
+import NIO
+
+extension Lifecycle.Handler {
+    /// Asynchronous `Lifecycle.Handler` based on an `EventLoopFuture`.
+    ///
+    /// - parameters:
+    ///    - future: the underlying `EventLoopFuture`
+    public static func async(_ future: @escaping () -> EventLoopFuture<Void>) -> Lifecycle.Handler {
+        return Lifecycle.Handler { callback in
+            future().whenComplete { result in
+                switch result {
+                case .success:
+                    callback(nil)
+                case .failure(let error):
+                    callback(error)
+                }
+            }
+        }
+    }
+}