SPB Git

Repository Public

SyncCoordinator.swift 6.0 KB 155 lines swift

1import Foundation2import Observation34/// Decides *when* to synchronize: shortly after local changes (debounced), when the app becomes active,5/// at a slow interval while it is in use, and with exponential backoff after failures. Nothing runs while6/// sync is turned off, the user is signed out or the device has no account key.7@MainActor8@Observable9final class SyncCoordinator {10    enum Phase: Equatable, Sendable {11        case off, signedOut, waitingForKey, idle, syncing, offline12        case failed(String)13    }1415    private(set) var phase: Phase = .signedOut16    private(set) var lastSync: Date?17    private(set) var lastReport = SyncReport()18    private(set) var pendingChanges = 01920    @ObservationIgnored let mirror: SyncDatabase21    @ObservationIgnored let account: AccountService22    @ObservationIgnored private let engine: SyncEngine23    @ObservationIgnored private let isEnabled: @MainActor () -> Bool24    /// Gathers local changes into the mirror just before a cycle (history, bookmarks, open tabs).25    @ObservationIgnored var captureLocalChanges: (@MainActor () -> Void)?26    /// Applies what a cycle pulled to the rest of the app.27    @ObservationIgnored var applyRemoteChanges: (@MainActor (Set<String>) -> Void)?2829    @ObservationIgnored private var scheduled: Task<Void, Never>?30    @ObservationIgnored private var periodic: Task<Void, Never>?31    @ObservationIgnored private var failures = 032    @ObservationIgnored private var active = false3334    nonisolated static let backoff: [TimeInterval] = [5, 15, 60, 300, 900]35    static let interval: TimeInterval = 3003637    init(account: AccountService, mirror: SyncDatabase, isEnabled: @escaping @MainActor () -> Bool) {38        self.account = account39        self.mirror = mirror40        self.isEnabled = isEnabled41        engine = SyncEngine(database: mirror, backend: account.backend, accountKey: account.accountKeyProvider)42        lastSync = mirror.meta("lastSync").flatMap(Double.init).map(Date.init(timeIntervalSince1970:))43        refreshPhase()44    }4546    /// Delay before retry number `failures` (1-based), capped.47    nonisolated static func retryDelay(afterFailures failures: Int) -> TimeInterval { backoff[min(max(failures, 1), backoff.count) - 1] }4849    private var canSync: Bool { isEnabled() && account.isSignedIn && account.keyStatus == .ready }5051    func refreshPhase() {52        if !isEnabled() { phase = .off }53        else if !account.isSignedIn { phase = .signedOut }54        else if account.keyStatus != .ready { phase = .waitingForKey }55        else if phase == .off || phase == .signedOut || phase == .waitingForKey { phase = .idle }56        pendingChanges = mirror.dirtyCount57    }5859    /// The app became active (launch, foreground): sync now and keep a slow heartbeat while it stays active.60    func start() {61        active = true62        periodic?.cancel()63        periodic = Task { [weak self] in64            while !Task.isCancelled {65                try? await Task.sleep(for: .seconds(Self.interval))66                guard !Task.isCancelled else { return }67                await self?.syncNow()68            }69        }70        requestSync(after: 0.5)71    }7273    /// The app went to the background or is quitting: no more timers (battery), pending changes stay queued on disk.74    func stop() {75        active = false76        periodic?.cancel(); periodic = nil77        scheduled?.cancel(); scheduled = nil78    }7980    /// Something changed locally: sync soon, coalescing bursts of changes into one cycle.81    func requestSync(after delay: TimeInterval = 4) {82        refreshPhase()83        guard canSync, active else { return }84        scheduled?.cancel()85        scheduled = Task { [weak self] in86            try? await Task.sleep(for: .seconds(delay))87            guard !Task.isCancelled else { return }88            await self?.syncNow()89        }90    }9192    /// Account or key state changed (signed in, approved, signed out).93    func accountStateChanged() {94        failures = 095        refreshPhase()96        if canSync { requestSync(after: 0.2) }97    }9899    @discardableResult100    func syncNow() async -> SyncReport? {101        refreshPhase()102        if account.isSignedIn, isEnabled(), account.keyStatus != .ready {103            // Maybe another device approved this one in the meantime.104            _ = try? await account.refreshKey()105            refreshPhase()106        }107        guard canSync, phase != .syncing else { return nil }108        phase = .syncing109        captureLocalChanges?()110        do {111            let report = try await engine.sync()112            failures = 0113            lastReport = report114            lastSync = Date()115            if !report.changedCollections.isEmpty { applyRemoteChanges?(report.changedCollections) }116            phase = .idle117            pendingChanges = mirror.dirtyCount118            return report119        } catch let error as BackendError {120            if error.kind == .unauthenticated {121                account.sessionWasRejected()122                refreshPhase()123            } else if error.code == "sync_not_initialized" {124                _ = try? await account.refreshKey()125                refreshPhase()126            } else {127                phase = error.kind == .offline || error.kind == .timeout ? .offline : .failed(error.message)128                scheduleRetry(minimum: error.retryAfter)129            }130        } catch SyncFailure.keyUnavailable, SyncFailure.keyMismatch {131            _ = try? await account.refreshKey()132            refreshPhase()133        } catch is CancellationError {134            phase = .idle135        } catch {136            phase = .failed(error.localizedDescription)137            scheduleRetry(minimum: nil)138        }139        pendingChanges = mirror.dirtyCount140        return nil141    }142143    private func scheduleRetry(minimum: TimeInterval?) {144        failures += 1145        guard active else { return }146        let delay = max(Self.retryDelay(afterFailures: failures), minimum ?? 0)147        scheduled?.cancel()148        scheduled = Task { [weak self] in149            try? await Task.sleep(for: .seconds(delay))150            guard !Task.isCancelled else { return }151            await self?.syncNow()152        }153    }154}155
Files main
Menu

Theme