Remove long running property

Author: FranzBusch

Sources/ServiceLifecycle/Service.swift

@@ -14,15 +14,13 @@
 
 /// This is the basic protocol that a service has to implement.
 public protocol Service: Sendable {
-    /// This indicates if the service is expected to be running for the entire duration.
-    /// If a long running service is returning from the ``Service/run()-1ougx`` method it is treated
-    /// as an unexpected early exit and all other services are going be cancelled.
-    var isLongRunning: Bool { get }
-
     /// This method is called when the ``ServiceRunner`` is starting all the services.
     ///
     /// Concrete implementation should execute their long running work in this method such as:
     /// - Handling incoming connections and requests
     /// - Background refreshes
+    ///
+    /// - Important: Returning or throwing from this method is indicating a failure of the service and will cause the ``ServiceRunner``
+    /// to cancel the child tasks of all other running services.
     func run() async throws
 }

Sources/ServiceLifecycle/ServiceRunner.swift

@@ -15,7 +15,7 @@
 import Logging
 import UnixSignals
 
-/// A ``ServiceRunner`` is responsible for running a number of services, setting up signal handling and shutting down services in the correct order.
+/// A ``ServiceRunner`` is responsible for running a number of services, setting up signal handling and signalling graceful shutdown to the services.
 public actor ServiceRunner: Sendable {
     /// The internal state of the ``ServiceRunner``.
     private enum State {
@@ -128,8 +128,6 @@ public actor ServiceRunner: Sendable {
                     }
                 }
 
-                var finishedServiceCount = 0
-
                 // We are going to wait for any of the services to finish or
                 // the signal sequence to throw an error.
                 while !group.isEmpty {
@@ -138,41 +136,17 @@ public actor ServiceRunner: Sendable {
 
                     switch result {
                     case .serviceFinished(let service):
-                        if service.isLongRunning {
-                            // If a long running service finishes early we treat this as an unexpected
-                            // early exit and have to cancel the rest of the services.
-                            self.logger.error(
-                                "Service finished unexpectedly",
-                                metadata: [
-                                    self.configuration.logging.serviceKey: "\(service)",
-                                ]
-                            )
-
-                            group.cancelAll()
-                            return .failure(ServiceRunnerError.serviceFinishedUnexpectedly())
-                        } else {
-                            // This service finished early but we expected it.
-                            // So we are just going to wait for the next service
-                            self.logger.debug(
-                                "Service finished",
-                                metadata: [
-                                    self.configuration.logging.serviceKey: "\(service)",
-                                ]
-                            )
-
-                            // We have to keep track of how many services finished to make sure
-                            // to stop when only the signal child task is left
-                            finishedServiceCount += 1
-                            if finishedServiceCount == self.services.count {
-                                // Every service finished. We can cancel the signal handling now
-                                // and return
-                                group.cancelAll()
-                                return .success(())
-                            } else {
-                                // There are still running services that we have to wait for
-                                continue
-                            }
-                        }
+                        // If a long running service finishes early we treat this as an unexpected
+                        // early exit and have to cancel the rest of the services.
+                        self.logger.error(
+                            "Service finished unexpectedly",
+                            metadata: [
+                                self.configuration.logging.serviceKey: "\(service)",
+                            ]
+                        )
+
+                        group.cancelAll()
+                        return .failure(ServiceRunnerError.serviceFinishedUnexpectedly())
 
                     case .serviceThrew(let service, let error):
                         // One of the servers threw an error. We have to cancel everything else now.

Sources/ServiceLifecycle/ServiceRunnerConfiguration.swift

@@ -29,7 +29,7 @@ public struct ServiceRunnerConfiguration: Hashable, Sendable {
         /// The logging key used for logging an error.
         public var errorKey = "error"
 
-        /// Initializes a new ``ServiceRunnerConfiguration/LoggingConfiguration-swift.struct``.
+        /// Initializes a new ``ServiceRunnerConfiguration/LoggingConfiguration``.
         public init() {}
     }