428 lines
16 KiB
Swift
428 lines
16 KiB
Swift
//
|
||
// MainView.swift
|
||
// iKeyMon
|
||
//
|
||
// Created by tracer on 30.03.25.
|
||
//
|
||
|
||
import SwiftUI
|
||
import Combine
|
||
import UserNotifications
|
||
|
||
struct MainView: View {
|
||
|
||
private static let serverOrderKeyStatic = "serverOrder"
|
||
private static let storedServersKeyStatic = "storedServers"
|
||
|
||
@State var showAddServerSheet: Bool = false
|
||
@State private var serverBeingEdited: Server?
|
||
@State private var serverToDelete: Server?
|
||
@State private var showDeleteConfirmation = false
|
||
@State private var isFetchingInfo: Bool = false
|
||
@AppStorage("pingInterval") private var pingInterval: Int = 10
|
||
@AppStorage("refreshInterval") private var refreshInterval: Int = 60
|
||
@AppStorage("enableStatusNotifications") private var enableStatusNotifications: Bool = true
|
||
@AppStorage("enableAlertNotifications") private var enableAlertNotifications: Bool = true
|
||
@State private var refreshTimer: Timer.TimerPublisher?
|
||
@State private var refreshSubscription: AnyCancellable?
|
||
@State private var pingTimer: Timer?
|
||
@State private var restartingServerID: UUID?
|
||
@State private var lastRefreshInterval: Int?
|
||
@State private var previousServiceStates: [String: String] = [:]
|
||
private let serverOrderKey = MainView.serverOrderKeyStatic
|
||
private let storedServersKey = MainView.storedServersKeyStatic
|
||
|
||
@State private var servers: [Server] = MainView.loadStoredServers()
|
||
|
||
// @State private var selectedServer: Server?
|
||
@State private var selectedServerID: UUID?
|
||
|
||
var body: some View {
|
||
var mainContent: some View {
|
||
NavigationSplitView {
|
||
List(selection: $selectedServerID) {
|
||
ForEach(servers) { server in
|
||
HStack {
|
||
Image(systemName: "dot.circle.fill")
|
||
.foregroundColor(server.pingable ? .green : .red)
|
||
Text(server.hostname)
|
||
}
|
||
.tag(server)
|
||
.contextMenu {
|
||
Button("Edit") {
|
||
print("Editing:", server.hostname)
|
||
serverBeingEdited = server
|
||
}
|
||
Divider()
|
||
Button("Delete", role: .destructive) {
|
||
serverToDelete = server
|
||
showDeleteConfirmation = true
|
||
}
|
||
}
|
||
}
|
||
.onMove(perform: moveServer)
|
||
}
|
||
.toolbar {
|
||
ToolbarItem(placement: .primaryAction) {
|
||
Button(action: { showAddServerSheet = true }) {
|
||
Image(systemName: "plus")
|
||
}
|
||
.help("Add Host")
|
||
}
|
||
}
|
||
.navigationTitle("Servers")
|
||
.onChange(of: selectedServerID) {
|
||
if let selectedServerID {
|
||
UserDefaults.standard.set(selectedServerID.uuidString, forKey: "selectedServerID")
|
||
fetchServerInfo(for: selectedServerID)
|
||
}
|
||
}
|
||
} detail: {
|
||
if let selectedServerID,
|
||
let index = servers.firstIndex(where: { selectedServerID == $0.id }) {
|
||
let serverID = servers[index].id
|
||
ServerDetailView(
|
||
server: $servers[index],
|
||
isFetching: isFetchingInfo,
|
||
canRestart: servers[index].info?.supportsRestartCommand == true,
|
||
isRestarting: restartingServerID == serverID
|
||
) {
|
||
await restartServer(for: serverID)
|
||
}
|
||
} else {
|
||
ContentUnavailableView("No Server Selected", systemImage: "server.rack")
|
||
}
|
||
}
|
||
}
|
||
return mainContent
|
||
.sheet(isPresented: $showAddServerSheet) {
|
||
ServerFormView(
|
||
mode: .add,
|
||
servers: $servers,
|
||
dismiss: { showAddServerSheet = false }
|
||
)
|
||
}
|
||
.sheet(item: $serverBeingEdited) { server in
|
||
ServerFormView(
|
||
mode: .edit(server),
|
||
servers: $servers,
|
||
dismiss: { serverBeingEdited = nil }
|
||
)
|
||
}
|
||
.alert("Are you sure you want to delete this server?", isPresented: $showDeleteConfirmation, presenting: serverToDelete) { server in
|
||
Button("Delete", role: .destructive) {
|
||
ServerFormView.delete(server: server, from: &servers)
|
||
}
|
||
Button("Cancel", role: .cancel) {}
|
||
}
|
||
.onAppear {
|
||
requestNotificationPermissions()
|
||
|
||
let initialID: UUID?
|
||
if let storedID = UserDefaults.standard.string(forKey: "selectedServerID"),
|
||
let uuid = UUID(uuidString: storedID),
|
||
servers.contains(where: { $0.id == uuid }) {
|
||
print("✅ [MainView] Restored selected server \(uuid)")
|
||
initialID = uuid
|
||
} else if let first = servers.first {
|
||
print("✅ [MainView] Selecting first server \(first.hostname)")
|
||
initialID = first.id
|
||
} else {
|
||
print("ℹ️ [MainView] No stored selection")
|
||
initialID = nil
|
||
}
|
||
|
||
selectedServerID = initialID
|
||
|
||
if let initialID {
|
||
Task {
|
||
await prefetchOtherServers(activeID: initialID)
|
||
}
|
||
}
|
||
setupTimers()
|
||
}
|
||
.onChange(of: pingInterval) { _, _ in
|
||
setupPingTimer()
|
||
}
|
||
.onChange(of: refreshInterval) { oldValue, newValue in
|
||
if oldValue != newValue {
|
||
setupRefreshTimer()
|
||
}
|
||
}
|
||
.frame(minWidth: 800, minHeight: 450)
|
||
}
|
||
|
||
private func fetchServerInfo(for id: UUID) {
|
||
guard let server = servers.first(where: { $0.id == id }) else {
|
||
print("❌ [MainView] fetchServerInfo: server not found for id \(id)")
|
||
return
|
||
}
|
||
guard let apiKey = KeychainHelper.loadApiKey(for: server.hostname)?.trimmingCharacters(in: .whitespacesAndNewlines),
|
||
!apiKey.isEmpty else {
|
||
print("❌ [MainView] fetchServerInfo: missing API key for \(server.hostname)")
|
||
return
|
||
}
|
||
guard let baseURL = URL(string: "https://\(server.hostname)") else {
|
||
print("❌ [MainView] Invalid base URL for \(server.hostname)")
|
||
return
|
||
}
|
||
|
||
isFetchingInfo = true
|
||
|
||
Task {
|
||
defer { isFetchingInfo = false }
|
||
do {
|
||
let api = try await APIFactory.detectAndCreateAPI(baseURL: baseURL, apiKey: apiKey)
|
||
let info = try await api.fetchServerSummary(apiKey: apiKey)
|
||
await MainActor.run {
|
||
if let index = servers.firstIndex(where: { $0.id == id }) {
|
||
var updated = servers[index]
|
||
updated.info = info
|
||
servers[index] = updated
|
||
checkServiceStatusChanges(for: server.hostname, newInfo: info)
|
||
}
|
||
}
|
||
} catch {
|
||
print("❌ Failed to fetch server data: \(error)")
|
||
}
|
||
}
|
||
}
|
||
|
||
private func prefetchOtherServers(activeID: UUID) async {
|
||
let others = servers.filter { $0.id != activeID }
|
||
await withTaskGroup(of: Void.self) { group in
|
||
for server in others {
|
||
group.addTask {
|
||
await fetchServerInfoAsync(for: server.id)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private func fetchServerInfoAsync(for id: UUID) async {
|
||
guard let server = servers.first(where: { $0.id == id }) else { return }
|
||
guard let apiKey = KeychainHelper.loadApiKey(for: server.hostname)?.trimmingCharacters(in: .whitespacesAndNewlines),
|
||
!apiKey.isEmpty,
|
||
let baseURL = URL(string: "https://\(server.hostname)")
|
||
else { return }
|
||
|
||
do {
|
||
let api = try await APIFactory.detectAndCreateAPI(baseURL: baseURL, apiKey: apiKey)
|
||
let info = try await api.fetchServerSummary(apiKey: apiKey)
|
||
await MainActor.run {
|
||
if let index = servers.firstIndex(where: { $0.id == id }) {
|
||
var updated = servers[index]
|
||
updated.info = info
|
||
servers[index] = updated
|
||
}
|
||
}
|
||
} catch {
|
||
print("❌ Prefetch failed for \(server.hostname): \(error)")
|
||
}
|
||
}
|
||
|
||
private func moveServer(from source: IndexSet, to destination: Int) {
|
||
servers.move(fromOffsets: source, toOffset: destination)
|
||
saveServerOrder()
|
||
}
|
||
|
||
private func saveServerOrder() {
|
||
let ids = servers.map { $0.id.uuidString }
|
||
UserDefaults.standard.set(ids, forKey: serverOrderKey)
|
||
print("💾 [MainView] Saved server order with \(ids.count) entries")
|
||
}
|
||
|
||
private struct PingResponse: Codable {
|
||
let response: String
|
||
}
|
||
|
||
func pingAllServers() {
|
||
for (index, server) in servers.enumerated() {
|
||
Task {
|
||
let apiKey = KeychainHelper.loadApiKey(for: server.hostname)?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
|
||
let pingable = await PingService.ping(hostname: server.hostname, apiKey: apiKey, notificationsEnabled: enableStatusNotifications)
|
||
await MainActor.run {
|
||
servers[index].pingable = pingable
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private func setupTimers() {
|
||
setupPingTimer()
|
||
setupRefreshTimer()
|
||
}
|
||
|
||
private func setupPingTimer() {
|
||
pingTimer?.invalidate()
|
||
pingAllServers()
|
||
pingTimer = Timer.scheduledTimer(withTimeInterval: Double(pingInterval), repeats: true) { _ in
|
||
pingAllServers()
|
||
}
|
||
}
|
||
|
||
private func setupRefreshTimer() {
|
||
refreshSubscription?.cancel()
|
||
refreshSubscription = nil
|
||
refreshTimer = Timer.publish(every: Double(refreshInterval), on: .main, in: .common)
|
||
refreshSubscription = refreshTimer?.autoconnect().sink { _ in
|
||
for server in servers {
|
||
fetchServerInfo(for: server.id)
|
||
}
|
||
}
|
||
}
|
||
|
||
private static func loadStoredServers() -> [Server] {
|
||
let defaults = UserDefaults.standard
|
||
guard let data = defaults.data(forKey: storedServersKeyStatic) else {
|
||
print("ℹ️ [MainView] No storedServers data found")
|
||
return []
|
||
}
|
||
do {
|
||
let saved = try JSONDecoder().decode([Server].self, from: data)
|
||
print("📦 [MainView] Loaded \(saved.count) servers from UserDefaults")
|
||
if let order = defaults.stringArray(forKey: serverOrderKeyStatic) {
|
||
let idMap = order.compactMap(UUID.init)
|
||
let sorted = saved.sorted { a, b in
|
||
guard
|
||
let i1 = idMap.firstIndex(of: a.id),
|
||
let i2 = idMap.firstIndex(of: b.id)
|
||
else { return false }
|
||
return i1 < i2
|
||
}
|
||
return sorted
|
||
}
|
||
return saved
|
||
} catch {
|
||
print("❌ [MainView] Failed to decode stored servers: \(error)")
|
||
return []
|
||
}
|
||
}
|
||
|
||
private func requestNotificationPermissions() {
|
||
Task {
|
||
do {
|
||
try await UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound])
|
||
} catch {
|
||
print("❌ [MainView] Failed to request notification permissions: \(error)")
|
||
}
|
||
}
|
||
}
|
||
|
||
private func checkServiceStatusChanges(for hostname: String, newInfo: ServerInfo) {
|
||
guard let ports = newInfo.ports else { return }
|
||
|
||
for port in ports {
|
||
let key = "\(hostname)-\(port.id)"
|
||
let previousStatus = previousServiceStates[key]
|
||
let currentStatus = port.status
|
||
|
||
previousServiceStates[key] = currentStatus
|
||
|
||
if let previousStatus, previousStatus != currentStatus {
|
||
if currentStatus == "offline" && enableStatusNotifications {
|
||
sendServiceNotification(service: port.service, hostname: hostname, status: "offline")
|
||
} else if currentStatus == "online" && previousStatus == "offline" && enableStatusNotifications {
|
||
sendServiceNotification(service: port.service, hostname: hostname, status: "online")
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private func sendServiceNotification(service: String, hostname: String, status: String) {
|
||
let content = UNMutableNotificationContent()
|
||
content.title = "\(service) \(status.uppercased())"
|
||
content.body = "\(service) on \(hostname) is \(status)"
|
||
content.sound = .default
|
||
|
||
let request = UNNotificationRequest(identifier: UUID().uuidString, content: content, trigger: nil)
|
||
UNUserNotificationCenter.current().add(request)
|
||
}
|
||
|
||
private func restartServer(for id: UUID) async -> ServerActionFeedback {
|
||
guard let server = servers.first(where: { $0.id == id }) else {
|
||
return ServerActionFeedback(
|
||
title: "Reboot Failed",
|
||
message: "The selected server could not be found."
|
||
)
|
||
}
|
||
|
||
guard server.info?.supportsRestartCommand == true else {
|
||
return ServerActionFeedback(
|
||
title: "Reboot Unavailable",
|
||
message: "\(server.hostname) does not support remote reboot via the API."
|
||
)
|
||
}
|
||
|
||
guard let apiKey = KeychainHelper.loadApiKey(for: server.hostname)?.trimmingCharacters(in: .whitespacesAndNewlines),
|
||
!apiKey.isEmpty else {
|
||
return ServerActionFeedback(
|
||
title: "Reboot Failed",
|
||
message: "No API key is configured for \(server.hostname)."
|
||
)
|
||
}
|
||
|
||
guard let baseURL = URL(string: "https://\(server.hostname)") else {
|
||
return ServerActionFeedback(
|
||
title: "Reboot Failed",
|
||
message: "The server URL for \(server.hostname) is invalid."
|
||
)
|
||
}
|
||
|
||
restartingServerID = id
|
||
defer { restartingServerID = nil }
|
||
|
||
do {
|
||
let api: AnyServerAPI
|
||
if let versionString = server.info?.apiVersion,
|
||
let versionedAPI = APIFactory.createAPI(baseURL: baseURL, versionString: versionString) {
|
||
api = versionedAPI
|
||
} else {
|
||
api = try await APIFactory.detectAndCreateAPI(baseURL: baseURL, apiKey: apiKey)
|
||
}
|
||
try await api.restartServer(apiKey: apiKey)
|
||
PingService.suppressChecks(for: server.hostname, duration: 90)
|
||
|
||
return ServerActionFeedback(
|
||
title: "Reboot Requested",
|
||
message: "The reboot command was sent to \(server.hostname). The host may become unavailable briefly while it restarts."
|
||
)
|
||
} catch let error as URLError where Self.isExpectedRestartDisconnect(error) {
|
||
PingService.suppressChecks(for: server.hostname, duration: 90)
|
||
return ServerActionFeedback(
|
||
title: "Reboot Requested",
|
||
message: "The reboot command appears to have been accepted by \(server.hostname). The connection dropped while the host was going away, which is expected during a reboot."
|
||
)
|
||
} catch APIError.httpError(404, let message) {
|
||
return ServerActionFeedback(
|
||
title: "Reboot Unavailable",
|
||
message: message ?? "\(server.hostname) returned 404 for /api/v2/server/reboot."
|
||
)
|
||
} catch {
|
||
return ServerActionFeedback(
|
||
title: "Reboot Failed",
|
||
message: error.localizedDescription
|
||
)
|
||
}
|
||
}
|
||
|
||
private static func isExpectedRestartDisconnect(_ error: URLError) -> Bool {
|
||
switch error.code {
|
||
case .timedOut,
|
||
.cannotConnectToHost,
|
||
.networkConnectionLost,
|
||
.notConnectedToInternet,
|
||
.cannotFindHost,
|
||
.dnsLookupFailed:
|
||
return true
|
||
default:
|
||
return false
|
||
}
|
||
}
|
||
}
|
||
|
||
#Preview {
|
||
MainView()
|
||
.environmentObject(SparkleUpdater())
|
||
}
|