Round 2 of adversarial review confirmed defects 2,3,4,5,7 fixed and raised three new ones; all three are fixed here, plus the guard-message nit. NEW-1 (the FAIL driver): the OneDrive send path overwrote the truthful status from handleDidShareItems with its own success text, silently dropping an archive failure and any state-refresh problem. The seam now takes the caller's success summary and composes ONE truthful message: summary (the share itself did complete) + archive error if any + refresh problems if any. Both callers (AirDrop delegate, OneDrive) pass their summary; the OneDrive text is never clobbered. NEW-2: if the replacement open session could not be created after the archive rename (disk full), the store kept reporting the already-archived session as the open one. SpoolStore now has a truth guard (ensureOpenSession): the open session is verified to really exist on disk and be in state .open before any read/mutate; a stale one is replaced by a genuinely fresh session, or the call fails loudly. Never a lie. NEW-3: archivedSessions() read the folder tie-break dates AFTER reconciliation, so a healed same-second session could bump its own modification date and outrank a genuinely newer peer. The dates are now read BEFORE reconciling. Nit: the startNewSession guard now reports "A new session is already being started." when the refusal is about a concurrent session start, not a send. Also added REDLINE_SELFTEST_PHASE=sendtruth (mirroring the existing =onedrive escape hatch) so the SEND-TRUTH selftest can run without the picker chain's display-dependent REGION-PERSIST phase. Evidence: 136 swift tests pass (2 new: OneDrive summary survives archiving; stale open session never returned as current). REDLINE_SELFTEST_PHASE=sendtruth -> SEND-TRUTH PASS. REDLINE_SELFTEST_PHASE=onedrive -> ONEDRIVE-SELFTEST PASS against the real OneDrive sync root.
228 lines
11 KiB
Swift
228 lines
11 KiB
Swift
import AppKit
|
||
import Darwin
|
||
import Foundation
|
||
import ShotdeckCore
|
||
|
||
/// Result of composing a send PDF. Kept so the self-test can drive the share
|
||
/// outcome without presenting a real AirDrop sheet.
|
||
struct ComposedSend: Sendable {
|
||
let fileName: String
|
||
let fileURL: URL
|
||
let pageCount: Int
|
||
}
|
||
|
||
extension AppModel: SendCapable {
|
||
public func send(anchor: NSView?) async {
|
||
guard !session.isEmpty, !isSending else { return }
|
||
// Same synchronous guard as AppModel.startNewSession(): refuse while a session
|
||
// start is mid-flight, instead of composing from a session directory that is
|
||
// being renamed into the archive.
|
||
guard !isStartingNewSession else {
|
||
setStatus("Finish starting the new session first.")
|
||
return
|
||
}
|
||
setSending(true)
|
||
|
||
// Wait for any IN-FLIGHT transport/folder reconcile (chooseTransport/
|
||
// chooseOneDriveFolder in SettingsView.swift) to fully settle BEFORE
|
||
// snapshotting transport/folder below. Without this, a toggle immediately
|
||
// followed by Send could let send() read a state that is still mid-transition
|
||
// — e.g. the watcher's recordUncommented flag briefly lagging the just-chosen
|
||
// transport, so a freshly-sent unmarked OneDrive PDF gets misreported as an
|
||
// already-returned document. `Task<Void, Never>.value` never throws, and
|
||
// awaiting nil is an immediate no-op (AirDrop mode, or no toggle in flight).
|
||
await pendingReconcileTask?.value
|
||
|
||
// Snapshot BOTH the transport AND the destination folder into local `let`s
|
||
// ONCE, before any further `await` in this function. chooseTransport/
|
||
// chooseOneDriveFolder also refuse outright (status "Finish the current send
|
||
// first.") while isSending is true, but this snapshot is the actual fix for the
|
||
// send-vs-switch race: even without that guard, everything below operates on
|
||
// these frozen values — composePDFForSend(outbox:transport:) takes both as
|
||
// parameters and never re-reads `self.outboxURL`/`self.transport` after a
|
||
// suspension point, so a concurrent transport switch mid-send can no longer
|
||
// land the PDF under one transport's folder while the archive/status branch
|
||
// runs the other's.
|
||
let transport = TransportSettings.transport()
|
||
let destinationFolder: URL
|
||
|
||
// OneDrive mode: verify the real destination exists, is writable, AND actually
|
||
// accepts a real write RIGHT NOW, before composing anything. `isWritableDirectory`
|
||
// alone is not enough — a OneDrive Files-On-Demand directory whose provider
|
||
// domain is signed out can report as existing and POSIX-writable while an
|
||
// actual write fails, so `probeWritable` writes-fsyncs-removes a tiny real probe
|
||
// file to catch that. `outboxURL` is kept in sync with the resolved OneDrive
|
||
// folder by bootstrap/chooseTransport/chooseOneDriveFolder, but this is
|
||
// re-resolved fresh here (never trusted stale) so a folder that vanished or lost
|
||
// its permissions since then (OneDrive signed out, external volume unmounted,
|
||
// folder deleted, chmod'd unwritable) is caught instead of silently attempted
|
||
// and surfacing as a generic PDF-composition failure.
|
||
if transport == .oneDrive {
|
||
guard let folder = OneDriveLocator.resolveOneDriveFolder(),
|
||
OneDriveLocator.isWritableDirectory(at: folder),
|
||
OneDriveLocator.probeWritable(at: folder)
|
||
else {
|
||
let path = OneDriveLocator.resolveOneDriveFolder()?.path
|
||
?? TransportSettings.storedOneDriveFolderPath()
|
||
?? "no OneDrive folder found"
|
||
setResolvedOneDriveFolder(nil)
|
||
setStatus(ShotdeckError.oneDriveFolderUnavailable(path: path).errorDescription)
|
||
setSending(false)
|
||
return
|
||
}
|
||
destinationFolder = folder
|
||
setResolvedOneDriveFolder(folder)
|
||
if outboxURL != folder || watchFolderURL != folder {
|
||
setFolderURLs(outbox: folder, watch: folder)
|
||
try? await watcher.updateWatchFolder(folder)
|
||
}
|
||
} else {
|
||
destinationFolder = outboxURL
|
||
}
|
||
|
||
let pending: ComposedSend
|
||
do {
|
||
pending = try await composePDFForSend(outbox: destinationFolder, transport: transport)
|
||
} catch {
|
||
// Never unlink the published PDF, and never unlink the temp file either:
|
||
// a rename failure would leave the complete document at the temp name.
|
||
setStatus((error as? ShotdeckError)?.errorDescription ?? "The PDF could not be built.")
|
||
setSending(false)
|
||
return
|
||
}
|
||
|
||
switch transport {
|
||
case .oneDrive:
|
||
// No AirDrop, no anchor needed — the PDF is already in the watched
|
||
// OneDrive folder. Archive immediately; the iPad marks it up in place.
|
||
let pageWord = pending.pageCount == 1 ? "page" : "pages"
|
||
await handleDidShareItems(
|
||
fileName: pending.fileName,
|
||
sentSummary: "Saved to OneDrive — \(pending.pageCount) \(pageWord). Open it in Files on your iPad."
|
||
)
|
||
setSending(false)
|
||
|
||
case .airDrop:
|
||
guard let anchor else {
|
||
handleDidFailToShareItems(fileName: pending.fileName)
|
||
setSending(false)
|
||
return
|
||
}
|
||
|
||
do {
|
||
try Sharing.airDrop(fileURL: pending.fileURL, from: anchor) { [weak self] success in
|
||
guard let self else { return }
|
||
if success {
|
||
let pageWord = pending.pageCount == 1 ? "page" : "pages"
|
||
await self.handleDidShareItems(
|
||
fileName: pending.fileName,
|
||
sentSummary: "Sent — \(pending.pageCount) \(pageWord)."
|
||
)
|
||
} else {
|
||
self.handleDidFailToShareItems(fileName: pending.fileName)
|
||
}
|
||
self.setSending(false)
|
||
}
|
||
} catch {
|
||
// canPerform false, no service, or no visible window: same as cancel.
|
||
handleDidFailToShareItems(fileName: pending.fileName)
|
||
setSending(false)
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Writes the PDF to `outboxDir` and records its path. Does not archive the session
|
||
/// and does not present AirDrop — that happens only after the share completes.
|
||
/// `outboxDir`/`transport` are passed in (values `send(anchor:)` snapshotted before
|
||
/// any await) rather than read from `self.outboxURL`/`self.transport` here, so a
|
||
/// concurrent transport switch mid-send can never redirect an in-flight compose to
|
||
/// a different folder. A write/rename failure specifically at the destination
|
||
/// folder (as opposed to composer.compose()'s own session/image-content failures)
|
||
/// is reported as `oneDriveFolderUnavailable` rather than the generic
|
||
/// `pdfCompositionFailed` when `transport == .oneDrive` — the File Provider edge
|
||
/// case where the folder looked writable moments ago in `send(anchor:)` but the
|
||
/// actual write still failed (e.g. OneDrive signed out mid-write).
|
||
func composePDFForSend(outbox outboxDir: URL, transport: SendTransport) async throws -> ComposedSend {
|
||
let workingSession = session
|
||
let composer = self.composer
|
||
let sourceDir = paths.sessionDirectory(workingSession.id)
|
||
let fileName = PDFComposer.fileName(for: workingSession)
|
||
let finalURL = outboxDir.appendingPathComponent(fileName)
|
||
// Same directory as the final target so the rename below is same-volume (atomic).
|
||
let tempURL = outboxDir.appendingPathComponent(".shotdeck-\(UUID().uuidString).pdf")
|
||
let title = "Redline – \(DubaiTime.stamp(workingSession.createdAt))"
|
||
|
||
// D-13: build off the main actor. Only Sendable values cross into the
|
||
// detached task — never `anchor` (NSView is not Sendable).
|
||
try await Task.detached(priority: .userInitiated) {
|
||
_ = try composer.compose(
|
||
session: workingSession,
|
||
imageURL: { capture in sourceDir.appendingPathComponent(capture.fileName) },
|
||
title: title,
|
||
to: tempURL
|
||
)
|
||
// POSIX rename onto `finalURL` replaces any same-name file in one
|
||
// directory operation; there is never a window where the PDF is gone.
|
||
if Darwin.rename(tempURL.path, finalURL.path) != 0 {
|
||
if transport == .oneDrive {
|
||
throw ShotdeckError.oneDriveFolderUnavailable(path: outboxDir.path)
|
||
}
|
||
throw ShotdeckError.pdfCompositionFailed(
|
||
reason: "could not publish the PDF: \(String(cString: strerror(errno)))"
|
||
)
|
||
}
|
||
do {
|
||
try AtomicFile.fsyncDirectory(at: outboxDir)
|
||
} catch {
|
||
if transport == .oneDrive {
|
||
throw ShotdeckError.oneDriveFolderUnavailable(path: outboxDir.path)
|
||
}
|
||
throw error
|
||
}
|
||
}.value
|
||
|
||
guard FileManager.default.fileExists(atPath: finalURL.path) else {
|
||
if transport == .oneDrive {
|
||
throw ShotdeckError.oneDriveFolderUnavailable(path: outboxDir.path)
|
||
}
|
||
throw ShotdeckError.pdfCompositionFailed(reason: "the PDF was not written to disk")
|
||
}
|
||
rememberLastComposedPDF(finalURL)
|
||
return ComposedSend(
|
||
fileName: fileName,
|
||
fileURL: finalURL,
|
||
pageCount: workingSession.captures.count
|
||
)
|
||
}
|
||
|
||
/// `NSSharingServiceDelegate.sharingService(_:didShareItems:)` seam — also the
|
||
/// OneDrive completion path. Composes ONE truthful status from the caller's success
|
||
/// summary (the share itself DID complete) plus, when they happened, the archive
|
||
/// error and any state-refresh problem — nothing is overwritten or hidden.
|
||
func handleDidShareItems(fileName: String, sentSummary: String) async {
|
||
guard !session.isEmpty else { return }
|
||
var message = sentSummary
|
||
do {
|
||
_ = try await spool.archiveCurrent(pdfFileName: fileName)
|
||
} catch {
|
||
message += " \((error as? ShotdeckError)?.errorDescription ?? "Could not archive the session.")"
|
||
}
|
||
// Refresh model state from the store on BOTH paths: after a successful archive
|
||
// the current session and the past-submissions list are stale until reloaded,
|
||
// and after a failure the store (not this model) knows whether the session
|
||
// actually moved. Any refresh problem is appended to the status, never hidden.
|
||
if let refreshProblem = await reloadFromSpool() {
|
||
message += " \(refreshProblem)"
|
||
}
|
||
setStatus(message)
|
||
}
|
||
|
||
/// `NSSharingServiceDelegate.sharingService(_:didFailToShareItems:error:)` seam,
|
||
/// also used when `canPerform` is false or the user cancels. Does not archive.
|
||
func handleDidFailToShareItems(fileName: String) {
|
||
setStatus(
|
||
"AirDrop didn't complete — nothing was sent. Your captures are still here; the PDF is on your \(outboxDisplayName) as \(fileName)."
|
||
)
|
||
}
|
||
}
|