Revert "cancellation handler (#4173)"

This reverts commit a1c8482.

Author: compnerd

Sources/Basics/Archiver+Zip.swift

@@ -12,83 +12,54 @@ import TSCBasic
 import Dispatch
 
 /// An `Archiver` that handles ZIP archives using the command-line `zip` and `unzip` tools.
-public struct ZipArchiver: Archiver, Cancellable {
+public struct ZipArchiver: Archiver {
     public var supportedExtensions: Set<String> { ["zip"] }
 
     /// The file-system implementation used for various file-system operations and checks.
     private let fileSystem: FileSystem
 
-    /// Helper for cancelling in-fligh requests
-    private let cancellator: Cancellator
-
     /// Creates a `ZipArchiver`.
     ///
     /// - Parameters:
     ///   - fileSystem: The file-system to used by the `ZipArchiver`.
     public init(fileSystem: FileSystem) {
         self.fileSystem = fileSystem
-        self.cancellator = Cancellator(observabilityScope: .none)
     }
 
     public func extract(
         from archivePath: AbsolutePath,
         to destinationPath: AbsolutePath,
         completion: @escaping (Result<Void, Error>) -> Void
     ) {
-        do {
-            guard self.fileSystem.exists(archivePath) else {
-                throw FileSystemError(.noEntry, archivePath)
-            }
-
-            guard self.fileSystem.isDirectory(destinationPath) else {
-                throw FileSystemError(.notDirectory, destinationPath)
-            }
+        guard fileSystem.exists(archivePath) else {
+            completion(.failure(FileSystemError(.noEntry, archivePath)))
+            return
+        }
 
-            let process = Process(arguments: ["unzip", archivePath.pathString, "-d", destinationPath.pathString])
-            guard let registrationKey = self.cancellator.register(process) else {
-                throw StringError("cancellation")
-            }
+        guard fileSystem.isDirectory(destinationPath) else {
+            completion(.failure(FileSystemError(.notDirectory, destinationPath)))
+            return
+        }
 
-            DispatchQueue.sharedConcurrent.async {
-                defer { self.cancellator.deregister(registrationKey) }
-                completion(.init(catching: {
-                    try process.launch()
-                    let processResult = try process.waitUntilExit()
-                    guard processResult.exitStatus == .terminated(code: 0) else {
-                        throw try StringError(processResult.utf8stderrOutput())
-                    }
-                }))
-            }
-        } catch {
-            return completion(.failure(error))
+        Process.popen(arguments: ["unzip", archivePath.pathString, "-d", destinationPath.pathString], queue: .sharedConcurrent) { result in
+            completion(result.tryMap { processResult in
+                guard processResult.exitStatus == .terminated(code: 0) else {
+                    throw try StringError(processResult.utf8stderrOutput())
+                }
+            })
         }
     }
 
     public func validate(path: AbsolutePath, completion: @escaping (Result<Bool, Error>) -> Void) {
-        do {
-            guard self.fileSystem.exists(path) else {
-                throw FileSystemError(.noEntry, path)
-            }
-
-            let process = Process(arguments: ["unzip", "-t", path.pathString])
-            guard let registrationKey = self.cancellator.register(process) else {
-                throw StringError("cancellation")
-            }
-
-            DispatchQueue.sharedConcurrent.async {
-                defer { self.cancellator.deregister(registrationKey) }
-                completion(.init(catching: {
-                    try process.launch()
-                    let processResult = try process.waitUntilExit()
-                    return processResult.exitStatus == .terminated(code: 0)
-                }))
-            }
-        } catch {
-            return completion(.failure(error))
+        guard fileSystem.exists(path) else {
+            completion(.failure(FileSystemError(.noEntry, path)))
+            return
         }
-    }
 
-    public func cancel(deadline: DispatchTime) throws {
-        try self.cancellator.cancel(deadline: deadline)
+        Process.popen(arguments: ["unzip", "-t", path.pathString], queue: .sharedConcurrent) { result in
+            completion(result.tryMap { processResult in
+                return processResult.exitStatus == .terminated(code: 0)
+            })
+        }
     }
 }

Sources/Basics/CMakeLists.txt

@@ -11,7 +11,6 @@ add_library(Basics
   Archiver+Zip.swift
   AuthorizationProvider.swift
   ByteString+Extensions.swift
-  Cancellator.swift
   ConcurrencyHelpers.swift
   Dictionary+Extensions.swift
   DispatchTimeInterval+Extensions.swift

Sources/Basics/Cancellator.swift

@@ -55,12 +55,9 @@ public final class ThreadSafeKeyValueStore<Key, Value> where Key: Hashable {
         }
     }
 
-    @discardableResult
-    public func clear() -> [Key: Value] {
+    public func clear() {
         self.lock.withLock {
-            let underlying = self.underlying
             self.underlying.removeAll()
-            return underlying
         }
     }
 
@@ -116,12 +113,9 @@ public final class ThreadSafeArrayStore<Value> {
         }
     }
 
-    @discardableResult
-    public func clear() -> [Value] {
+    public func clear() {
         self.lock.withLock {
-            let underlying = self.underlying
-            self.underlying.removeAll()
-            return underlying
+            self.underlying = []
         }
     }
 

Sources/Basics/ConcurrencyHelpers.swift

@@ -27,21 +27,6 @@ extension DispatchTimeInterval {
         }
     }
 
-    public func nanoseconds() -> Int? {
-        switch self {
-        case .seconds(let value):
-            return value.multipliedReportingOverflow(by: 1_000_000_000).partialValue
-        case .milliseconds(let value):
-            return value.multipliedReportingOverflow(by: 1_000_000).partialValue
-        case .microseconds(let value):
-            return value.multipliedReportingOverflow(by: 1000).partialValue
-        case .nanoseconds(let value):
-            return value
-        default:
-            return nil
-        }
-    }
-
     public func milliseconds() -> Int? {
         switch self {
         case .seconds(let value):
@@ -96,7 +81,7 @@ extension DispatchTimeInterval {
 #if os(Linux) || os(Windows) || os(Android) || os(OpenBSD)
 extension DispatchTime {
     public func distance(to: DispatchTime) -> DispatchTimeInterval {
-        let duration = to.uptimeNanoseconds.subtractingReportingOverflow(self.uptimeNanoseconds).partialValue
+        let duration = to.uptimeNanoseconds - self.uptimeNanoseconds
         return .nanoseconds(duration >= Int.max ? Int.max : Int(duration))
     }
 }