SPB Git

Repository Public

SyncEngine.swift 5.6 KB 150 lines swift

1//2//  SP Chat iOS3//  File: SPChat-iOS/Core/Sync/SyncEngine.swift4//  Description: Follows the server's change feed (SSE `GET /api/events`, pull `GET /api/sync`) while the app is active:5//               reconnects with backoff, keeps its cursor in the local store and hands batched refresh plans to the app.6//7//  Author: Simon-Pierre Boucher8//  Contact: contact@spboucher.ai9//1011import Foundation12import Observation1314@MainActor15@Observable16final class SyncEngine {17    enum Status: Equatable, Sendable { case idle, connecting, live, waiting }18    private(set) var status: Status = .idle19    private(set) var lastChangeAt: Date?20    /// Last sequence number applied (nil until the first contact with the server).21    private(set) var cursor: Int?2223    @ObservationIgnored private let api: ChatAPI24    @ObservationIgnored private let store: LocalStore25    @ObservationIgnored private let waitUntilOnline: () async -> Void26    /// Applies a plan (re-reads what changed). Set by `AppEnvironment`.27    @ObservationIgnored var onPlan: ((SyncPlan) async -> Void)?28    @ObservationIgnored private var feedTask: Task<Void, Never>?29    @ObservationIgnored private var flushTask: Task<Void, Never>?30    @ObservationIgnored private var pending = SyncPlan()31    @ObservationIgnored private var loadedCursor = false32    static let cursorKey = "sync.cursor"3334    init(api: ChatAPI, store: LocalStore, waitUntilOnline: @escaping () async -> Void) { self.api = api; self.store = store; self.waitUntilOnline = waitUntilOnline }3536    private func loadCursor() async {37        guard !loadedCursor else { return }38        loadedCursor = true39        cursor = await store.value(Int.self, for: Self.cursorKey)40    }41    private func advance(to seq: Int) {42        guard seq > (cursor ?? -1) else { return }43        cursor = seq44        let store = store45        Task { await store.setValue(seq, for: Self.cursorKey) }46    }4748    /// Opens the feed (app active, signed in). Idempotent.49    func start() {50        guard feedTask == nil else { return }51        feedTask = Task { [weak self] in await self?.run() }52    }5354    /// Closes the feed (background, sign-out). The cursor is kept: the next start replays what was missed.55    func stop() {56        feedTask?.cancel(); feedTask = nil57        flushTask?.cancel(); flushTask = nil58        status = .idle59    }6061    func reset() async {62        stop(); cursor = nil; pending = SyncPlan(); loadedCursor = true63        // the store itself is wiped by the caller; nothing else to forget64    }6566    /// Pull variant (foreground, background refresh): what changed since the cursor, as one plan.67    /// Returns nil when the server could not be reached.68    @discardableResult69    func pull() async -> SyncPlan? {70        await loadCursor()71        guard let after = cursor else {72            // first contact: everything was just loaded; only remember where the feed stands73            guard let r = try? await api.sync(after: 0) else { return nil }74            advance(to: r.head)75            return SyncPlan()76        }77        guard let r = try? await api.sync(after: after) else { return nil }78        var plan = SyncPlan()79        if r.truncated { plan = .all; advance(to: r.head) } else { advance(to: max(plan.absorb(r.events, cursor: after), r.head)) }80        if !plan.isEmpty { lastChangeAt = Date(); await onPlan?(plan) }81        return plan82    }8384    private func run() async {85        await loadCursor()86        var failures = 087        while !Task.isCancelled {88            await waitUntilOnline()89            if Task.isCancelled { return }90            if cursor == nil { _ = await pull() }91            guard let after = cursor else { await backoff(&failures); continue }92            status = .connecting93            do {94                switch try await api.openEvents(after: after) {95                case .json: break96                case .events(let bytes):97                    for try await sse in SSEStream.events(from: bytes) {98                        if Task.isCancelled { return }99                        handle(SyncFeedEvent(sse: sse))100                        failures = 0101                    }102                }103            } catch let e as APIError where e.kind == .locked { status = .idle; feedTask = nil; return }104            catch { }105            if Task.isCancelled { return }106            await backoff(&failures)107        }108    }109110    private func backoff(_ failures: inout Int) async {111        status = .waiting112        failures += 1113        let delay = min(1000 * (1 << min(failures, 5)), 30_000) + Int.random(in: 0...500)114        try? await Task.sleep(for: .milliseconds(delay))115    }116117    /// Applies one feed event. Changes are batched: a burst (a turn writes several rows) becomes one plan.118    func handle(_ event: SyncFeedEvent) {119        switch event {120        case .hello: status = .live121        case .change(let e):122            let before = cursor ?? -1123            advance(to: pending.absorb([e], cursor: before))124            scheduleFlush()125        case .resync(let head):126            pending = .all; advance(to: head); scheduleFlush()127        case .other: break128        }129    }130131    private func scheduleFlush() {132        guard flushTask == nil else { return }133        flushTask = Task { [weak self] in134            try? await Task.sleep(for: .milliseconds(350))135            guard let self, !Task.isCancelled else { return }136            self.flushTask = nil137            await self.flush()138        }139    }140141    /// Hands the batched plan to the app now (tests call it directly).142    func flush() async {143        flushTask?.cancel(); flushTask = nil144        let plan = pending; pending = SyncPlan()145        guard !plan.isEmpty else { return }146        lastChangeAt = Date()147        await onPlan?(plan)148    }149}150
Files main
Menu

Theme