Files
VCCPlusOSS/platforms/macos/App/SoftwareLibraryState.swift
T

146 lines
7.7 KiB
Swift

// SPDX-License-Identifier: GPL-3.0-or-later
import Foundation
import Combine
// Catalog releases are immutable reference data. This independent, atomic file
// retains personal choices across catalog replacements, including IDs absent
// from a later catalog. Installation receipts are reconciled into it without editing SQLite.
@MainActor
final class SoftwareLibraryState: ObservableObject {
struct Installation: Codable, Equatable, Sendable {
let releaseID: String
let packageSHA256: String
let installedAt: Date
let workingDirectory: URL
}
private struct Document: Codable, Sendable {
var version = 1
var favoriteTitleIDs: Set<String> = []
var preferredReleaseIDs: [String: String] = [:]
var installedReleases: [String: Installation] = [:]
}
@Published private(set) var favoriteTitleIDs: Set<String> = []
@Published private(set) var preferredReleaseIDs: [String: String] = [:]
@Published private(set) var installedReleases: [String: Installation] = [:]
@Published private(set) var saveError: String?
let directory: URL
private let fileURL: URL
private let queue = DispatchQueue(label: "com.brianholman.vccplus.library-state", qos: .utility)
private var companion: (any CompanionLibraryAccess)?
private var remoteSave: Task<Void, Never>?
private var maySave = true
private var revision = 0
init(directory: URL) {
self.directory = directory
fileURL = directory.appendingPathComponent("LibraryState.json")
do {
guard FileManager.default.fileExists(atPath: fileURL.path) else { return }
let file = try FileHandle(forReadingFrom: fileURL)
defer { try? file.close() }
let data = try file.read(upToCount: 1_048_577) ?? Data()
guard data.count <= 1_048_576 else { throw StateFailure.invalid }
let document = try JSONDecoder().decode(Document.self, from: data)
guard document.version == 1,
document.favoriteTitleIDs.allSatisfy(Self.validID),
document.preferredReleaseIDs.allSatisfy({ Self.validID($0.key) && Self.validID($0.value) }),
document.installedReleases.allSatisfy({ key, entry in
key == entry.releaseID && Self.validID(key) && entry.packageSHA256.count == 64
&& entry.packageSHA256.allSatisfy(\.isHexDigit) && entry.workingDirectory.isFileURL
}) else { throw StateFailure.invalid }
favoriteTitleIDs = document.favoriteTitleIDs
preferredReleaseIDs = document.preferredReleaseIDs
installedReleases = document.installedReleases
} catch {
maySave = false // Preserve unreadable/newer state rather than overwriting it.
saveError = "Your saved Library choices could not be read. The original file has been preserved at \(fileURL.path). \(error.localizedDescription)"
}
}
/// In-memory presentation only. All persistence stays in VCC Plus.
init(companion: any CompanionLibraryAccess) {
self.companion = companion
directory = FileManager.default.temporaryDirectory.appendingPathComponent("VCCCompanionPresentation", isDirectory: true)
fileURL = directory.appendingPathComponent("Unused.json")
}
func applyRemoteSnapshot(_ snapshot: CompanionLibrarySnapshot) {
let visible = snapshot.catalog.companionDisksOnly
let titles = Set(visible.titles.map(\.id)), releases = Set(visible.releases.map(\.id))
favoriteTitleIDs = snapshot.favorites.intersection(titles)
preferredReleaseIDs = snapshot.preferredReleaseIDs.filter { titles.contains($0.key) && releases.contains($0.value) }
installedReleases = Dictionary(snapshot.installations.filter { releases.contains($0.releaseID) }.map { ($0.releaseID, $0) }, uniquingKeysWith: { _, last in last })
saveError = nil
}
private func sendRemote(_ request: CompanionLibraryRequest) {
guard let companion else { return }
revision += 1
let revision = revision, previous = remoteSave
remoteSave = Task { [weak self] in
await previous?.value
do {
let response = try await companion.libraryRequest(request)
if let message = response.errorMessage { throw CompanionLibraryFailure(message: message) }
guard let self, self.revision == revision else { return }
if let snapshot = response.snapshot { self.applyRemoteSnapshot(snapshot) }
} catch {
guard let self, self.revision == revision else { return }
self.saveError = error.localizedDescription
}
}
}
func isFavorite(_ titleID: String) -> Bool { favoriteTitleIDs.contains(titleID) }
func preferredReleaseID(for titleID: String) -> String? { preferredReleaseIDs[titleID] }
func toggleFavorite(_ titleID: String) {
guard maySave, Self.validID(titleID) else { return }
if favoriteTitleIDs.contains(titleID) { favoriteTitleIDs.remove(titleID) }
else { favoriteTitleIDs.insert(titleID) }
if companion != nil {
sendRemote(.init(operation: .setFavorite, titleID: titleID, enabled: favoriteTitleIDs.contains(titleID)))
} else { save() }
}
func selectRelease(_ releaseID: String, for titleID: String) {
guard maySave, Self.validID(titleID), Self.validID(releaseID), preferredReleaseIDs[titleID] != releaseID else { return }
preferredReleaseIDs[titleID] = releaseID
if companion != nil { sendRemote(.init(operation: .setPreferredRelease, releaseID: releaseID, titleID: titleID)) }
else { save() }
}
// Receipts are the authoritative installation record; personal choices stay separate.
func replaceInstallations(_ installations: [Installation]) {
let entries = Dictionary(installations.map { ($0.releaseID, $0) }, uniquingKeysWith: { _, latest in latest })
guard entries != installedReleases else { return }
installedReleases = entries
if maySave && companion == nil { save() }
}
// Used at shutdown/testing to await all already-enqueued atomic writes.
func flush() async {
await remoteSave?.value
await withCheckedContinuation { continuation in queue.async { continuation.resume() } }
}
private static func validID(_ id: String) -> Bool {
!id.isEmpty && id.utf8.count <= 256 && !id.unicodeScalars.contains(where: CharacterSet.controlCharacters.contains)
}
private func save() {
let document = Document(favoriteTitleIDs: favoriteTitleIDs, preferredReleaseIDs: preferredReleaseIDs, installedReleases: installedReleases)
revision += 1
let revision = revision, destination = fileURL
queue.async { [weak self] in
let failure: String?
do {
let encoder = JSONEncoder(); encoder.outputFormatting = [.sortedKeys]
let data = try encoder.encode(document)
guard data.count <= 1_048_576 else { throw StateFailure.invalid }
try FileManager.default.createDirectory(at: destination.deletingLastPathComponent(), withIntermediateDirectories: true)
try data.write(to: destination, options: .atomic)
failure = nil
} catch { failure = "Library choices could not be saved: \(error.localizedDescription)" }
Task { @MainActor [weak self] in
guard let self, self.revision == revision else { return }
self.saveError = failure
}
}
}
private enum StateFailure: LocalizedError {
case invalid
var errorDescription: String? { "The Library choices file is damaged or uses an unsupported version." }
}
}