Add VM stats

Author: jkmassel

Sources/hostmgr/HostMgrCommand.swift

@@ -6,7 +6,7 @@ import libhostmgr
 @main
 struct Hostmgr: AsyncParsableCommand {
 
-    private static var appVersion = "0.17.2"
+    private static var appVersion = "0.51.0"
 
     static var configuration = CommandConfiguration(
         abstract: "A utility for managing VM hosts",

Sources/hostmgr/VMCommand.swift

@@ -3,41 +3,22 @@ import ArgumentParser
 
 struct VMCommand: AsyncParsableCommand {
 
-    static var universalCommands: [ParsableCommand.Type] = [
-        VMDetailsCommand.self,
-        VMExistsCommand.self,
-        VMFetchCommand.self,
-        VMListCommand.self,
-        VMStartCommand.self,
-        VMStopCommand.self,
-        VMPublish.self,
-        VMCloneCommand.self,
-    ]
-
-    static var appleSiliconCommands: [ParsableCommand.Type] {
-        #if arch(arm64)
-        return [
-            VMCreateCommand.self,
-            VMPackageCommand.self
-        ]
-        #else
-        return []
-        #endif
-    }
-
-    static var intelCommands: [ParsableCommand.Type] {
-        #if arch(x86_64)
-        return [
-            VMCleanCommand.self
-        ]
-        #else
-        return []
-        #endif
-    }
-
     static let configuration = CommandConfiguration(
         commandName: "vm",
         abstract: "Allows working with VMs",
-        subcommands: universalCommands + appleSiliconCommands + intelCommands
+        subcommands: [
+            VMCleanCommand.self,
+            VMCloneCommand.self,
+            VMCreateCommand.self,
+            VMDetailsCommand.self,
+            VMExistsCommand.self,
+            VMFetchCommand.self,
+            VMListCommand.self,
+            VMPackageCommand.self,
+            VMPublishCommand.self,
+            VMStartCommand.self,
+            VMStatsCommand.self,
+            VMStopCommand.self,
+        ]
     )
 }

Sources/hostmgr/commands/vm/VMClean.swift

@@ -6,7 +6,7 @@ struct VMCleanCommand: AsyncParsableCommand {
 
     static let configuration = CommandConfiguration(
         commandName: "clean",
-        abstract: "Clean up the VM environment prior to running another job"
+        abstract: "Remove VMs that haven't been used recently"
     )
 
     @DIInjected
@@ -15,9 +15,21 @@ struct VMCleanCommand: AsyncParsableCommand {
     enum CodingKeys: CodingKey {}
 
     func run() async throws {
-        try await vmManager.resetVMWorkingDirectory()
+        let cutoff = Date(timeIntervalSinceNow: 90 * 24 * 60 * 60 * -1) // 90 days
 
-        // Clean up no-longer-needed local images
-        try await vmManager.purgeUnusedImages()
+        let unusedImages = try await vmManager.getVMImages(unusedSince: cutoff)
+
+        if unusedImages.isEmpty {
+            Console.exit("No VMs to clean", style: .success)
+        }
+
+        Console.info("Removing VMs not used since \(Format.date(cutoff, style: .short))")
+
+        for image in unusedImages {
+            try await vmManager.removeVM(name: image.vm)
+            Console.success("Removed \(image.vm)")
+        }
+
+        Console.success("Finished cleaning VMs")
     }
 }

Sources/hostmgr/commands/vm/VMPublish.swift

@@ -2,7 +2,7 @@ import Foundation
 import ArgumentParser
 import libhostmgr
 
-struct VMPublish: AsyncParsableCommand {
+struct VMPublishCommand: AsyncParsableCommand {
 
     static let configuration = CommandConfiguration(
         commandName: "publish",

Sources/hostmgr/commands/vm/VMStats.swift

@@ -0,0 +1,26 @@
+import Foundation
+import ArgumentParser
+import libhostmgr
+
+struct VMStatsCommand: AsyncParsableCommand {
+
+    static let configuration = CommandConfiguration(
+        commandName: "stats",
+        abstract: "Show VM usage stats"
+    )
+
+    @DIInjected
+    var vmManager: any VMManager
+
+    enum CodingKeys: CodingKey {}
+
+    func run() async throws {
+        let stats = try await vmManager.getVMUsageStats().grouped().asTable()
+
+        if stats.isEmpty {
+            Console.error("No VM stats found")
+        } else {
+            Console.printTable(data: stats, columnTitles: ["VM Name", "Count"])
+        }
+    }
+}

Sources/hostmgr/commands/vm/VMStop.swift

@@ -39,6 +39,6 @@ struct VMStopCommand: AsyncParsableCommand {
             throw CleanExit.helpRequest()
         }
 
-        try await vmManager.stopVM(name: identifier)
+        try await vmManager.stopVM(handle: identifier)
     }
 }

Sources/libhostmgr/CLI/Console.swift

@@ -282,8 +282,8 @@ extension Console {
         return Console().printList(list, title: title)
     }
 
-    @discardableResult public static func printTable(data: Table, columnTitles: [String] = []) -> Self {
-        return Console().printTable(data: data, columnTitles: columnTitles)
+    @discardableResult public static func printTable(data: TableConvertable, columnTitles: [String] = []) -> Self {
+        return Console().printTable(data: data.asTable(), columnTitles: columnTitles)
     }
 
     public static func crash(_ error: HostmgrError) -> Never {
@@ -334,3 +334,13 @@ extension Console {
 public extension ProgressKind {
     static let installation = ProgressKind(rawValue: "installation")
 }
+
+public protocol TableConvertable {
+    func asTable() -> Console.Table
+}
+
+extension Console.Table: TableConvertable {
+    public func asTable() -> Console.Table {
+        return self
+    }
+}

Sources/libhostmgr/CLI/Format.swift

@@ -76,6 +76,10 @@ public struct Format {
         return formatter.string(from: Date(), to: Date() + interval) ?? "a while"
     }
 
+    public static func date(_ date: Date, style: DateFormatter.Style) -> String {
+        DateFormatter.localizedString(from: date, dateStyle: style, timeStyle: .none)
+    }
+
     public static func percentage(_ number: Decimal) -> String {
         return percentage(NSDecimalNumber(decimal: number))
     }

Sources/libhostmgr/Model/Paths.swift

@@ -74,6 +74,8 @@ public struct Paths {
             .appendingPathComponent(storageDirectoryIdentifier)
     }
 
+    public static var vmUsageFile = stateRoot.appending(path: "vm-usage")
+
     public static func toAppleSiliconVM(named name: String) -> URL {
         Paths.vmImageStorageDirectory.appendingPathComponent(name).appendingPathExtension("bundle")
     }

Sources/libhostmgr/Model/VMUsageRecord.swift

@@ -0,0 +1,69 @@
+import Foundation
+
+public struct VMUsageRecord {
+    public let vm: String
+    public let date: Date
+
+    public func isAfter(date: Date) -> Bool {
+        self.date.timeIntervalSince1970 > date.timeIntervalSince1970
+    }
+}
+
+public struct VMUsageAggregate {
+    public let vm: String
+    public let count: Int
+    public let lastUsed: Date
+
+    public func merging(_ records: [VMUsageRecord]) -> VMUsageAggregate {
+        records.reduce(self) { $0.merging($1) }
+    }
+
+    public func merging(_ record: VMUsageRecord) -> VMUsageAggregate {
+        let count = self.count + 1
+        let date = record.isAfter(date: lastUsed) ? record.date : lastUsed
+        return VMUsageAggregate(vm: vm, count: count, lastUsed: date)
+    }
+
+    public static func from(record: VMUsageRecord) -> VMUsageAggregate {
+        VMUsageAggregate(vm: record.vm, count: 1, lastUsed: record.date)
+    }
+
+    public static func from(_ records: [VMUsageRecord]) -> VMUsageAggregate? {
+        var mutableRecords = records
+
+        guard let initialrecord = mutableRecords.popLast() else {
+            return nil
+        }
+
+        return VMUsageAggregate.from(record: initialrecord).merging(mutableRecords)
+    }
+}
+
+extension [VMUsageRecord] {
+    public func grouped() -> [VMUsageAggregate] {
+        var aggregatedRecords = [String: VMUsageAggregate]()
+
+        for record in self {
+            if let existingRecord = aggregatedRecords[record.vm] {
+                aggregatedRecords[record.vm] = existingRecord.merging(record)
+            } else {
+                aggregatedRecords[record.vm] = VMUsageAggregate.from(record: record)
+            }
+        }
+
+        return aggregatedRecords.values.map { $0 }
+    }
+
+}
+
+extension [VMUsageAggregate] {
+    public func asTable() -> Console.Table {
+        self.map { [$0.vm, String($0.count)] }
+    }
+
+    func unused(since: Date) -> Self {
+        self.filter {
+            $0.lastUsed.timeIntervalSince1970 < since.timeIntervalSince1970
+        }
+    }
+}