Adopt CLI Progress Indicator

Author: jkmassel

Sources/hostmgr/commands/benchmark/NetworkBenchmark.swift

@@ -27,32 +27,16 @@ struct NetworkBenchmark: AsyncParsableCommand {
             region: Configuration.shared.vmImagesRegion
         )
 
+        let progressBar = Console.startFileDownload(file.imageObject)
+
         try await manager.download(
             object: file.imageObject,
             to: FileManager.default.temporaryFilePath(),
-            progressCallback: self.updateProgress
+            progressCallback: progressBar.update
         )
     }
 
     private func imageSizeSort(_ lhs: RemoteVMImage, _ rhs: RemoteVMImage) -> Bool {
         lhs.imageObject.size < rhs.imageObject.size
     }
-
-    private func updateProgress(_ progress: FileTransferProgress) {
-        Self.limiter.perform {
-            let downloadedSize = ByteCountFormatter.string(fromByteCount: Int64(progress.current), countStyle: .file)
-            let totalSize = ByteCountFormatter.string(fromByteCount: Int64(progress.total), countStyle: .file)
-
-            let secondsElapsed = Date().timeIntervalSince(startDate)
-            let perSecond = Double(progress.current) / Double(secondsElapsed)
-
-            // Don't continue unless the rate can be represented by `Int64`
-            guard perSecond.isNormal else {
-                return
-            }
-
-            let rate = ByteCountFormatter.string(fromByteCount: Int64(perSecond), countStyle: .file)
-            logger.info("Downloaded \(downloadedSize) of \(totalSize) [Rate: \(rate) per second]")
-        }
-    }
 }

Sources/hostmgr/commands/sync/SyncVMImagesCommand.swift

@@ -60,10 +60,12 @@ struct SyncVMImagesCommand: AsyncParsableCommand, FollowsCommandPolicies {
 
         let limiter = Limiter(policy: .throttle, operationsPerSecond: 1)
 
+        let progressBar = Console.startImageDownload(image)
         try await RemoteVMRepository().download(image: image, to: destination) { progress in
+            progressBar.update(progress)
+
             limiter.perform {
                 try? recordHeartbeat()
-                logger.info("\(progress.decimalPercent)% complete")
             }
         }
 

Sources/hostmgr/commands/vm/image/remote/VMRemoteImageDownload.swift

@@ -48,17 +48,10 @@ struct VMRemoteImageDownload: AsyncParsableCommand {
         let sleepManager = SystemSleepManager(reason: "Downloading \(remoteImage.fileName)")
         sleepManager.disable()
 
-        let progressBar = Tqdm(
-            description: "Downloading \(remoteImage.fileName)",
-            total: Int(remoteImage.imageObject.size),
-            unit: " bytes",
-            unitScale: true
-        )
+        let progressBar = Console.startImageDownload(remoteImage)
 
         try await remote.download(image: remoteImage, to: destination) {
-            progressBar.update(n: $0.percent)
+            progressBar.update($0)
         }
-
-        progressBar.close()
     }
 }

Sources/libhostmgr/S3Manager.swift

@@ -146,30 +146,65 @@ public struct S3Object {
 }
 
 public struct FileTransferProgress {
-    public let current: Int
-    public let total: Int
+    public typealias Percentage = Decimal
 
-    public let estimatedTimeRemaining: TimeInterval?
+    let current: Int
+    let total: Int
 
-    public init(current: Int, total: Int, estimatedTimeRemaining: TimeInterval?) {
+    public init(current: Int, total: Int) {
         self.current = current
         self.total = total
-        self.estimatedTimeRemaining = estimatedTimeRemaining
     }
 
-    public var percent: Int {
-        Int(decimalPercent)
+    public var percent: Percentage {
+        Decimal(Double(self.current) / Double(self.total) * 100.0)
     }
 
-    public var decimalPercent: Double {
-        Double(current) / Double(total) * 100
+    public var downloadedData: String {
+        ByteCountFormatter.string(fromByteCount: Int64(current), countStyle: .file)
+    }
+
+    public var totalData: String {
+        ByteCountFormatter.string(fromByteCount: Int64(total), countStyle: .file)
+    }
+
+    public func dataRate(timeIntervalSinceStart interval: TimeInterval) -> String {
+        let bytesPerSecond = Double(current) / interval
+
+        // Don't continue unless the rate can be represented by `Int64`
+        guard bytesPerSecond.isNormal else {
+            return ByteCountFormatter.string(fromByteCount: 0, countStyle: .file)
+        }
+
+        return ByteCountFormatter.string(fromByteCount: Int64(bytesPerSecond), countStyle: .file)
+    }
+
+    public func estimatedTimeRemaining(timeIntervalSinceStart interval: TimeInterval) -> TimeInterval {
+        let bytesPerSecond = Double(current) / interval
+
+        // Don't continue unless the rate makes some kind of sense
+        guard bytesPerSecond.isNormal else {
+            return .infinity
+        }
+
+        let totalNumberOfSeconds = Double(total) / bytesPerSecond
+
+        return totalNumberOfSeconds - interval
+    }
+
+    public var formattedPercentage: String {
+        let formatter = NumberFormatter()
+        formatter.alwaysShowsDecimalSeparator = true
+        formatter.roundingMode = .down
+        formatter.minimumFractionDigits = 2
+        formatter.maximumFractionDigits = 2
+        return formatter.string(from: percent as NSDecimalNumber)!
     }
 
     static func progressData(from progress: Progress) -> FileTransferProgress {
         return FileTransferProgress(
             current: Int(progress.completedUnitCount),
-            total: Int(progress.totalUnitCount),
-            estimatedTimeRemaining: progress.estimatedTimeRemaining
+            total: Int(progress.totalUnitCount)
         )
     }
 }