WP-0b: AtomicFile, Log, FolderSettings foundation per SPEC-A1a; drop stale hotkey string
This commit is contained in:
@@ -0,0 +1,104 @@
|
||||
import Foundation
|
||||
import Darwin
|
||||
|
||||
public enum AtomicFile {
|
||||
/// Writes `data` to `url` durably: writes to `<url>.tmp` in the SAME directory as `url`,
|
||||
/// fsyncs that file descriptor, closes it, rename()s it onto `url` (atomic same-volume
|
||||
/// rename), then opens `url`'s containing directory and fsyncs THAT too (a rename is only
|
||||
/// durable once its directory entry is flushed). Never uses `Data.write(to:)` — that call
|
||||
/// does not fsync.
|
||||
public static func write(_ data: Data, to url: URL) throws {
|
||||
let finalPath = url.path
|
||||
let directoryURL = url.deletingLastPathComponent()
|
||||
let tmpURL = directoryURL.appendingPathComponent(url.lastPathComponent + ".tmp")
|
||||
let tmpPath = tmpURL.path
|
||||
|
||||
// Clear a stale .tmp left by a previous crash. ENOENT (nothing to clear) is fine.
|
||||
if unlink(tmpPath) != 0 && errno != ENOENT {
|
||||
throw ShotdeckError.spoolWriteFailed(
|
||||
path: finalPath,
|
||||
underlying: "could not clear a stale temp file: \(String(cString: strerror(errno)))")
|
||||
}
|
||||
|
||||
let fd = open(tmpPath, O_WRONLY | O_CREAT | O_TRUNC, 0o644)
|
||||
guard fd >= 0 else {
|
||||
throw ShotdeckError.spoolWriteFailed(
|
||||
path: finalPath, underlying: "open failed: \(String(cString: strerror(errno)))")
|
||||
}
|
||||
|
||||
var writeFailure: String?
|
||||
data.withUnsafeBytes { (raw: UnsafeRawBufferPointer) in
|
||||
var remaining = raw.count
|
||||
var pointer = raw.baseAddress
|
||||
while remaining > 0 {
|
||||
let n = Darwin.write(fd, pointer, remaining)
|
||||
if n < 0 {
|
||||
if errno == EINTR { continue }
|
||||
writeFailure = "write failed: \(String(cString: strerror(errno)))"
|
||||
break
|
||||
}
|
||||
if n == 0 { break }
|
||||
remaining -= n
|
||||
pointer = pointer?.advanced(by: n)
|
||||
}
|
||||
}
|
||||
if let writeFailure {
|
||||
close(fd)
|
||||
_ = unlink(tmpPath)
|
||||
throw ShotdeckError.spoolWriteFailed(path: finalPath, underlying: writeFailure)
|
||||
}
|
||||
if fsync(fd) != 0 {
|
||||
let message = "fsync failed: \(String(cString: strerror(errno)))"
|
||||
close(fd)
|
||||
_ = unlink(tmpPath)
|
||||
throw ShotdeckError.spoolWriteFailed(path: finalPath, underlying: message)
|
||||
}
|
||||
if close(fd) != 0 {
|
||||
_ = unlink(tmpPath)
|
||||
throw ShotdeckError.spoolWriteFailed(
|
||||
path: finalPath, underlying: "close failed: \(String(cString: strerror(errno)))")
|
||||
}
|
||||
if rename(tmpPath, finalPath) != 0 {
|
||||
let message = "rename failed: \(String(cString: strerror(errno)))"
|
||||
_ = unlink(tmpPath)
|
||||
throw ShotdeckError.spoolWriteFailed(path: finalPath, underlying: message)
|
||||
}
|
||||
try fsyncDirectory(at: directoryURL)
|
||||
}
|
||||
|
||||
/// Encodes `value` with `JSONEncoder` (`.sortedKeys, .prettyPrinted`,
|
||||
/// `.dateEncodingStrategy = .iso8601`) and writes it through `write(_:to:)`.
|
||||
public static func writeJSON<T: Encodable>(_ value: T, to url: URL) throws {
|
||||
let encoder = JSONEncoder()
|
||||
encoder.outputFormatting = [.sortedKeys, .prettyPrinted]
|
||||
encoder.dateEncodingStrategy = .iso8601
|
||||
let data: Data
|
||||
do {
|
||||
data = try encoder.encode(value)
|
||||
} catch {
|
||||
throw ShotdeckError.spoolWriteFailed(
|
||||
path: url.path, underlying: "JSON encoding failed: \(error.localizedDescription)")
|
||||
}
|
||||
try write(data, to: url)
|
||||
}
|
||||
|
||||
/// Opens `url` (must be an existing directory) and fsyncs it. Used after any directory-
|
||||
/// level `rename()` (moving/renaming a whole session directory) — the same durability
|
||||
/// requirement as the internal directory-fsync inside `write(_:to:)`, exposed for callers
|
||||
/// that rename directories themselves (SpoolStore).
|
||||
public static func fsyncDirectory(at url: URL) throws {
|
||||
let fd = open(url.path, O_RDONLY | O_DIRECTORY)
|
||||
guard fd >= 0 else {
|
||||
throw ShotdeckError.spoolWriteFailed(
|
||||
path: url.path,
|
||||
underlying: "could not open directory for fsync: \(String(cString: strerror(errno)))")
|
||||
}
|
||||
let result = fsync(fd)
|
||||
close(fd)
|
||||
if result != 0 {
|
||||
throw ShotdeckError.spoolWriteFailed(
|
||||
path: url.path,
|
||||
underlying: "directory fsync failed: \(String(cString: strerror(errno)))")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,111 @@
|
||||
import Foundation
|
||||
|
||||
/// User-configurable overrides for the outbox (PDF send destination) and watch folder
|
||||
/// (AirDrop return), backed by UserDefaults. Shotdeck is NOT App-Sandboxed (no
|
||||
/// `com.apple.security.app-sandbox` entitlement in this build — it is a plain, unsandboxed
|
||||
/// SwiftPM executable). Security-scoped bookmarks exist to let a SANDBOXED app retain access
|
||||
/// to a user-picked file/folder outside its container across relaunches; an unsandboxed
|
||||
/// process already has the invoking user's own filesystem permissions on every launch, so a
|
||||
/// plain absolute path stored in UserDefaults is sufficient — including for a mounted network
|
||||
/// share, which resolves by path the same as any local folder for as long as it is mounted.
|
||||
public enum FolderSettings {
|
||||
public static let outboxDefaultsKey = "ai.flowmaster.shotdeck.outbox"
|
||||
public static let watchFolderDefaultsKey = "ai.flowmaster.shotdeck.watchFolder"
|
||||
|
||||
/// Raw stored path (or nil if never set / cleared). For display in Settings — does NOT
|
||||
/// validate that the path still exists.
|
||||
public static func storedOutboxPath(defaults: UserDefaults = .standard) -> String? {
|
||||
defaults.string(forKey: outboxDefaultsKey)
|
||||
}
|
||||
|
||||
public static func storedWatchFolderPath(defaults: UserDefaults = .standard) -> String? {
|
||||
defaults.string(forKey: watchFolderDefaultsKey)
|
||||
}
|
||||
|
||||
/// Persists a user-chosen folder as its absolute POSIX path.
|
||||
public static func setOutbox(_ url: URL, defaults: UserDefaults = .standard) {
|
||||
defaults.set(url.path, forKey: outboxDefaultsKey)
|
||||
}
|
||||
|
||||
public static func setWatchFolder(_ url: URL, defaults: UserDefaults = .standard) {
|
||||
defaults.set(url.path, forKey: watchFolderDefaultsKey)
|
||||
}
|
||||
|
||||
/// Removes the override; resolve() falls back to the default again.
|
||||
public static func resetOutbox(defaults: UserDefaults = .standard) {
|
||||
defaults.removeObject(forKey: outboxDefaultsKey)
|
||||
}
|
||||
|
||||
public static func resetWatchFolder(defaults: UserDefaults = .standard) {
|
||||
defaults.removeObject(forKey: watchFolderDefaultsKey)
|
||||
}
|
||||
|
||||
/// Resolves both folders. A stored override wins only if it is set AND the directory it
|
||||
/// names still exists; otherwise falls back to the default (Desktop / Downloads). Never
|
||||
/// throws — a missing/bad override is logged via `Log.ui` and silently replaced.
|
||||
public static func resolve(
|
||||
defaults: UserDefaults = .standard,
|
||||
fileManager: FileManager = .default
|
||||
) -> (outbox: URL, watch: URL) {
|
||||
let outbox = resolveOne(
|
||||
storedPath: storedOutboxPath(defaults: defaults),
|
||||
fallback: defaultOutbox(fileManager: fileManager),
|
||||
label: "outbox", fileManager: fileManager)
|
||||
let watch = resolveOne(
|
||||
storedPath: storedWatchFolderPath(defaults: defaults),
|
||||
fallback: defaultWatchFolder(fileManager: fileManager),
|
||||
label: "watch", fileManager: fileManager)
|
||||
return (outbox, watch)
|
||||
}
|
||||
|
||||
/// Builds an `AppSupportPaths` using `root` (defaults to the standard
|
||||
/// `~/Library/Application Support/Shotdeck`, computed the same way
|
||||
/// `AppSupportPaths.standard()` does, when `root` is nil) plus whatever `resolve()`
|
||||
/// returns for outbox/watch. This is the ONLY place that combines FolderSettings with
|
||||
/// AppSupportPaths — call this everywhere in the app instead of `AppSupportPaths.standard()`.
|
||||
/// `root` is exposed purely so tests can point it at a temporary directory instead of the
|
||||
/// user's real Application Support folder.
|
||||
public static func resolvedAppSupportPaths(
|
||||
root: URL? = nil,
|
||||
defaults: UserDefaults = .standard,
|
||||
fileManager: FileManager = .default
|
||||
) throws -> AppSupportPaths {
|
||||
let resolvedRoot: URL
|
||||
if let root {
|
||||
resolvedRoot = root
|
||||
} else {
|
||||
let appSupportParent = try fileManager.url(
|
||||
for: .applicationSupportDirectory, in: .userDomainMask,
|
||||
appropriateFor: nil, create: true)
|
||||
resolvedRoot = appSupportParent.appendingPathComponent("Shotdeck", isDirectory: true)
|
||||
}
|
||||
let folders = resolve(defaults: defaults, fileManager: fileManager)
|
||||
return try AppSupportPaths(root: resolvedRoot, outbox: folders.outbox, watchFolder: folders.watch)
|
||||
}
|
||||
|
||||
private static func defaultOutbox(fileManager: FileManager) -> URL {
|
||||
fileManager.urls(for: .desktopDirectory, in: .userDomainMask).first
|
||||
?? fileManager.homeDirectoryForCurrentUser.appendingPathComponent("Desktop", isDirectory: true)
|
||||
}
|
||||
|
||||
private static func defaultWatchFolder(fileManager: FileManager) -> URL {
|
||||
fileManager.urls(for: .downloadsDirectory, in: .userDomainMask).first
|
||||
?? fileManager.homeDirectoryForCurrentUser.appendingPathComponent("Downloads", isDirectory: true)
|
||||
}
|
||||
|
||||
private static func resolveOne(
|
||||
storedPath: String?,
|
||||
fallback: URL,
|
||||
label: String,
|
||||
fileManager: FileManager
|
||||
) -> URL {
|
||||
guard let storedPath else { return fallback }
|
||||
var isDirectory: ObjCBool = false
|
||||
let exists = fileManager.fileExists(atPath: storedPath, isDirectory: &isDirectory)
|
||||
guard exists, isDirectory.boolValue else {
|
||||
Log.ui.warning("Configured \(label, privacy: .public) folder \(storedPath, privacy: .public) no longer exists; falling back to the default.")
|
||||
return fallback
|
||||
}
|
||||
return URL(fileURLWithPath: storedPath, isDirectory: true)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
import os
|
||||
|
||||
public enum Log {
|
||||
public static let spool = Logger(subsystem: "ai.flowmaster.shotdeck", category: "spool")
|
||||
public static let pdf = Logger(subsystem: "ai.flowmaster.shotdeck", category: "pdf")
|
||||
public static let capture = Logger(subsystem: "ai.flowmaster.shotdeck", category: "capture")
|
||||
public static let returns = Logger(subsystem: "ai.flowmaster.shotdeck", category: "returns")
|
||||
public static let ui = Logger(subsystem: "ai.flowmaster.shotdeck", category: "ui")
|
||||
}
|
||||
Reference in New Issue
Block a user