299 lines
13 KiB
Swift
299 lines
13 KiB
Swift
import AppKit
|
|
import Foundation
|
|
|
|
struct ServerDefinition: Identifiable, Codable, Hashable {
|
|
var id = UUID()
|
|
var name: String
|
|
var vmName: String
|
|
var vmUUID: String? = nil
|
|
var host: String
|
|
var sshUser: String
|
|
var sshPort: Int = 22
|
|
var sshIdentityFile: String = ""
|
|
var mailpitPort: Int?
|
|
|
|
static let orion = ServerDefinition(name: "Orion", vmName: "Ubuntu Linux Server", host: "10.211.55.100", sshUser: "sysadmin", sshPort: 22, sshIdentityFile: "", mailpitPort: 8025)
|
|
}
|
|
|
|
|
|
struct ParallelsVM: Identifiable, Hashable {
|
|
let id: String
|
|
let name: String
|
|
let status: String
|
|
let ipAddress: String
|
|
let operatingSystem: String
|
|
var bundlePath: String?
|
|
|
|
var symbol: String {
|
|
switch operatingSystem {
|
|
case "Windows": return "desktopcomputer"
|
|
case "Ubuntu": return "server.rack"
|
|
case "Debian": return "server.rack"
|
|
case "Fedora": return "server.rack"
|
|
case "CentOS": return "server.rack"
|
|
case "Alpine": return "server.rack"
|
|
case "Oracle Linux": return "server.rack"
|
|
default: return "desktopcomputer"
|
|
}
|
|
}
|
|
|
|
static func detectOS(_ name: String) -> String {
|
|
let value = name.lowercased()
|
|
|
|
if value.contains("windows") { return "Windows" }
|
|
if value.contains("ubuntu") { return "Ubuntu" }
|
|
if value.contains("debian") { return "Debian" }
|
|
if value.contains("fedora") { return "Fedora" }
|
|
if value.contains("centos") { return "CentOS" }
|
|
if value.contains("alpine") { return "Alpine" }
|
|
if value.contains("oracle") { return "Oracle Linux" }
|
|
if value.contains("rocky") { return "Rocky Linux" }
|
|
if value.contains("alma") { return "AlmaLinux" }
|
|
if value.contains("arch") { return "Arch Linux" }
|
|
if value.contains("gentoo") { return "Gentoo" }
|
|
if value.contains("freebsd") { return "FreeBSD" }
|
|
|
|
return "Other"
|
|
}
|
|
}
|
|
|
|
@MainActor
|
|
final class OrionVMController: ObservableObject {
|
|
enum VMStatus: Equatable {
|
|
case checking, running, stopped, suspended, transitioning, unavailable(String)
|
|
var title: String { switch self { case .checking: "Checking…"; case .running: "Running"; case .stopped: "Stopped"; case .suspended: "Suspended"; case .transitioning: "Working…"; case .unavailable: "Unavailable" } }
|
|
var symbolName: String { switch self { case .running: "server.rack"; case .stopped: "power"; case .suspended: "pause.circle"; case .transitioning, .checking: "arrow.triangle.2.circlepath"; case .unavailable: "exclamationmark.triangle" } }
|
|
}
|
|
|
|
@Published var servers: [ServerDefinition] { didSet { saveServers() } }
|
|
@Published var statuses: [UUID: VMStatus] = [:]
|
|
@Published var busyServers: Set<UUID> = []
|
|
@Published var lastError: String?
|
|
@Published var discoveredVMs: [ParallelsVM] = []
|
|
@Published var selectedVMIDs: Set<String> = []
|
|
@Published var discovering = false
|
|
private var timer: Timer?
|
|
private let defaultsKey = "serverDefinitions.v2"
|
|
|
|
init() {
|
|
if let data = UserDefaults.standard.data(forKey: defaultsKey), let saved = try? JSONDecoder().decode([ServerDefinition].self, from: data), !saved.isEmpty { servers = saved }
|
|
else { servers = [.orion] }
|
|
Task {
|
|
await discoverVMs()
|
|
await refreshAll()
|
|
}
|
|
timer = Timer.scheduledTimer(withTimeInterval: 5, repeats: true) { [weak self] _ in Task { @MainActor in await self?.refreshAll() } }
|
|
}
|
|
deinit { timer?.invalidate() }
|
|
|
|
|
|
func discoverVMs() async {
|
|
guard !discovering else { return }
|
|
|
|
discovering = true
|
|
defer { discovering = false }
|
|
|
|
do {
|
|
let output = try await runPrlctl(["list", "-a", "-j"])
|
|
|
|
guard let data = output.data(using: .utf8),
|
|
let records = try JSONSerialization.jsonObject(
|
|
with: data
|
|
) as? [[String: Any]] else {
|
|
throw OrionError.commandFailed(
|
|
"Invalid Parallels VM discovery response."
|
|
)
|
|
}
|
|
|
|
discoveredVMs = records.compactMap { record in
|
|
guard let uuid = record["uuid"] as? String,
|
|
let name = record["name"] as? String else {
|
|
return nil
|
|
}
|
|
|
|
let status = record["status"] as? String ?? "unknown"
|
|
let ip = record["ip_configured"] as? String ?? ""
|
|
|
|
return ParallelsVM(
|
|
id: uuid,
|
|
name: name,
|
|
status: status,
|
|
ipAddress: ip == "-" ? "" : ip,
|
|
operatingSystem: ParallelsVM.detectOS(name),
|
|
bundlePath: nil
|
|
)
|
|
}
|
|
.sorted {
|
|
$0.name.localizedStandardCompare($1.name)
|
|
== .orderedAscending
|
|
}
|
|
|
|
// Keep selections only for VMs still present.
|
|
let available = Set(discoveredVMs.map(\.id))
|
|
selectedVMIDs.formIntersection(available)
|
|
|
|
// Associate existing configurations with discovered VMs.
|
|
// This preserves the original Orion configuration.
|
|
for machine in discoveredVMs {
|
|
guard let index = servers.firstIndex(where: {
|
|
$0.vmUUID == machine.id ||
|
|
($0.vmUUID == nil && $0.vmName == machine.name)
|
|
}) else {
|
|
continue
|
|
}
|
|
|
|
if servers[index].vmUUID == nil {
|
|
servers[index].vmUUID = machine.id
|
|
}
|
|
}
|
|
|
|
} catch {
|
|
lastError = error.localizedDescription
|
|
}
|
|
}
|
|
|
|
func isIntegrated(_ machine: ParallelsVM) -> Bool {
|
|
servers.contains {
|
|
$0.vmUUID == machine.id ||
|
|
($0.vmUUID == nil && $0.vmName == machine.name)
|
|
}
|
|
}
|
|
|
|
func toggleSelection(_ machine: ParallelsVM) {
|
|
if selectedVMIDs.contains(machine.id) {
|
|
selectedVMIDs.remove(machine.id)
|
|
} else {
|
|
selectedVMIDs.insert(machine.id)
|
|
}
|
|
}
|
|
|
|
func selectAllVMs() {
|
|
selectedVMIDs = Set(discoveredVMs.map(\.id))
|
|
}
|
|
|
|
func clearVMSelection() {
|
|
selectedVMIDs.removeAll()
|
|
}
|
|
|
|
func integrateSelectedVMs() {
|
|
let selected = discoveredVMs.filter {
|
|
selectedVMIDs.contains($0.id)
|
|
}
|
|
|
|
for machine in selected {
|
|
guard !isIntegrated(machine) else { continue }
|
|
|
|
let server = ServerDefinition(
|
|
name: machine.name,
|
|
vmName: machine.name,
|
|
vmUUID: machine.id,
|
|
host: machine.ipAddress,
|
|
sshUser: "sysadmin",
|
|
sshPort: 22,
|
|
sshIdentityFile: "",
|
|
mailpitPort: nil
|
|
)
|
|
|
|
add(server)
|
|
}
|
|
|
|
selectedVMIDs.removeAll()
|
|
}
|
|
|
|
func icon(for machine: ParallelsVM) -> NSImage? {
|
|
guard let path = machine.bundlePath,
|
|
FileManager.default.fileExists(atPath: path) else {
|
|
return nil
|
|
}
|
|
|
|
return NSWorkspace.shared.icon(forFile: path)
|
|
}
|
|
|
|
func status(for server: ServerDefinition) -> VMStatus { statuses[server.id] ?? .checking }
|
|
func isBusy(_ server: ServerDefinition) -> Bool { busyServers.contains(server.id) }
|
|
func add(_ server: ServerDefinition) { servers.append(server); Task { await refreshStatus(server) } }
|
|
func update(_ server: ServerDefinition) { if let i = servers.firstIndex(where: { $0.id == server.id }) { servers[i] = server; Task { await refreshStatus(server) } } }
|
|
func delete(at offsets: IndexSet) { for i in offsets { statuses[servers[i].id] = nil }; servers.remove(atOffsets: offsets) }
|
|
|
|
func refreshAll() async { for server in servers { await refreshStatus(server) } }
|
|
func refreshStatus(_ server: ServerDefinition) async {
|
|
guard !isBusy(server) else { return }
|
|
do {
|
|
let output = try await runPrlctl(["status", server.vmName]); let value = output.lowercased()
|
|
if value.contains("running") { statuses[server.id] = .running }
|
|
else if value.contains("stopped") { statuses[server.id] = .stopped }
|
|
else if value.contains("suspended") || value.contains("paused") { statuses[server.id] = .suspended }
|
|
else { statuses[server.id] = .unavailable(output.trimmingCharacters(in: .whitespacesAndNewlines)) }
|
|
} catch { statuses[server.id] = .unavailable(error.localizedDescription) }
|
|
}
|
|
|
|
func start(_ s: ServerDefinition) { perform(["start", s.vmName], server: s) }
|
|
func stop(_ s: ServerDefinition) { perform(["stop", s.vmName], server: s) }
|
|
func restart(_ s: ServerDefinition) { perform(["restart", s.vmName], server: s) }
|
|
func forceStop(_ s: ServerDefinition) { perform(["stop", s.vmName, "--kill"], server: s) }
|
|
|
|
private func perform(_ arguments: [String], server: ServerDefinition) {
|
|
guard !isBusy(server) else { return }; busyServers.insert(server.id); statuses[server.id] = .transitioning; lastError = nil
|
|
Task { do { _ = try await runPrlctl(arguments) } catch { lastError = error.localizedDescription }; busyServers.remove(server.id); try? await Task.sleep(for: .seconds(1)); await refreshStatus(server) }
|
|
}
|
|
|
|
func openSSH(_ s: ServerDefinition) {
|
|
let userHost = "\(s.sshUser)@\(s.host)"
|
|
var command = "/usr/bin/ssh -p \(s.sshPort)"
|
|
let identity = s.sshIdentityFile.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
if !identity.isEmpty {
|
|
command += " -i \(shellQuote((identity as NSString).expandingTildeInPath))"
|
|
}
|
|
command += " \(shellQuote(userHost))"
|
|
|
|
do {
|
|
// Terminal reliably opens executable .command files without requiring
|
|
// Apple Events/Automation permission from this menu-bar application.
|
|
let directory = FileManager.default.temporaryDirectory
|
|
.appendingPathComponent("OrionToolbar", isDirectory: true)
|
|
try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
|
|
|
|
let safeName = s.name.replacingOccurrences(of: "/", with: "-")
|
|
let scriptURL = directory.appendingPathComponent("SSH-\(safeName).command")
|
|
let script = """
|
|
#!/bin/zsh
|
|
clear
|
|
echo "Connecting to \(s.name) (\(userHost))..."
|
|
exec \(command)
|
|
"""
|
|
try script.write(to: scriptURL, atomically: true, encoding: .utf8)
|
|
try FileManager.default.setAttributes([.posixPermissions: 0o700], ofItemAtPath: scriptURL.path)
|
|
|
|
guard let terminalURL = NSWorkspace.shared.urlForApplication(withBundleIdentifier: "com.apple.Terminal") else {
|
|
lastError = "Terminal.app could not be found."
|
|
return
|
|
}
|
|
|
|
let configuration = NSWorkspace.OpenConfiguration()
|
|
configuration.activates = true
|
|
NSWorkspace.shared.open([scriptURL], withApplicationAt: terminalURL, configuration: configuration) { _, error in
|
|
Task { @MainActor in
|
|
if let error { self.lastError = "Could not open Terminal: \(error.localizedDescription)" }
|
|
}
|
|
}
|
|
} catch {
|
|
lastError = "Could not create SSH launcher: \(error.localizedDescription)"
|
|
}
|
|
}
|
|
|
|
private func shellQuote(_ value: String) -> String {
|
|
"'" + value.replacingOccurrences(of: "'", with: "'\"'\"'") + "'"
|
|
}
|
|
func openMailpit(_ s: ServerDefinition) { if let p = s.mailpitPort, let url = URL(string: "http://\(s.host):\(p)") { NSWorkspace.shared.open(url) } }
|
|
func openParallels() { NSWorkspace.shared.openApplication(at: URL(fileURLWithPath: "/Applications/Parallels Desktop.app"), configuration: .init()) }
|
|
|
|
private func saveServers() { if let data = try? JSONEncoder().encode(servers) { UserDefaults.standard.set(data, forKey: defaultsKey) } }
|
|
private func prlctlURL() -> URL? { ["/usr/local/bin/prlctl", "/Applications/Parallels Desktop.app/Contents/MacOS/prlctl"].map(URL.init(fileURLWithPath:)).first { FileManager.default.isExecutableFile(atPath: $0.path) } }
|
|
private func runPrlctl(_ arguments: [String]) async throws -> String {
|
|
guard let executable = prlctlURL() else { throw OrionError.prlctlNotFound }
|
|
return try await Task.detached(priority: .userInitiated) { let p = Process(); let pipe = Pipe(); p.executableURL = executable; p.arguments = arguments; p.standardOutput = pipe; p.standardError = pipe; try p.run(); p.waitUntilExit(); let out = String(decoding: pipe.fileHandleForReading.readDataToEndOfFile(), as: UTF8.self); guard p.terminationStatus == 0 else { throw OrionError.commandFailed(out) }; return out }.value
|
|
}
|
|
}
|
|
|
|
enum OrionError: LocalizedError { case prlctlNotFound, commandFailed(String); var errorDescription: String? { switch self { case .prlctlNotFound: "Parallels prlctl was not found."; case .commandFailed(let o): o.trimmingCharacters(in: .whitespacesAndNewlines) } } }
|