TeraStoreObservation.swift (5421B)
1 import Foundation 2 3 /// Stable configuration inputs, excluding changing service observation evidence. 4 struct TeraPresentationConfiguration: Equatable { 5 let publicKey: String 6 let relayProfile: String? 7 let context: TeraLocalNetwork 8 let blossom: TeraBlossomConfigurationStatus? 9 10 init(snapshot: TeraRuntimeSnapshot) { 11 publicKey = snapshot.identity.publicKeyHex 12 relayProfile = snapshot.relay?.profile 13 context = .defaultContext(snapshot: snapshot) 14 blossom = snapshot.blossomConfiguration 15 } 16 } 17 18 /// At most one entry per fixed notification domain; a gap subsumes every domain. 19 struct TeraObservationBatch: Equatable { 20 private(set) var domains: Set<TeraRuntimeChangeKind> = [] 21 private(set) var resnapshot = false 22 23 static var currentState: Self { 24 Self(resnapshot: true) 25 } 26 27 var isEmpty: Bool { 28 !resnapshot && domains.isEmpty 29 } 30 31 func contains(anyOf kinds: Set<TeraRuntimeChangeKind>) -> Bool { 32 resnapshot || !domains.isDisjoint(with: kinds) 33 } 34 35 mutating func insert(_ change: TeraRuntimeChange) { 36 if change.delivery == .resnapshotRequired || change.revision.rawValue == nil { 37 self = .currentState 38 } else if !resnapshot, change.kind != .initial { 39 domains.insert(change.kind) 40 } 41 } 42 } 43 44 /// One stream and one refresh worker per store. Ingestion never waits for a 45 /// query; hints arriving during that query retain a bounded final refresh. 46 @MainActor 47 final class TeraStoreObservation { 48 private var generation = TeraSessionGeneration.initial 49 private var task: Task<Void, Never>? 50 private var refreshTask: Task<Void, Never>? 51 private var pending = TeraObservationBatch() 52 53 var isActive: Bool { 54 task != nil 55 } 56 57 /// Join the existing reconciliation when it superseded an awaited initial read. 58 func waitForRefresh() async { 59 await refreshTask?.value 60 } 61 62 deinit { 63 task?.cancel() 64 refreshTask?.cancel() 65 } 66 67 func stop() { 68 generation = generation.invalidated() 69 task?.cancel() 70 task = nil 71 refreshTask?.cancel() 72 refreshTask = nil 73 pending = TeraObservationBatch() 74 } 75 76 func start( 77 client: TeraRuntimeClient, 78 buffer: (capacity: Int, delay: @Sendable (UInt32) async throws -> Void), 79 state: @escaping @MainActor (TeraRuntimeObservationState) -> Void, 80 accepts: @escaping @MainActor (TeraRuntimeChange) -> Bool, 81 invalidate: @escaping @MainActor (TeraObservationBatch) -> Void = { _ in }, 82 refresh: @escaping @MainActor (TeraObservationBatch) async -> Void 83 ) { 84 guard task == nil, generation.isActive else { return } 85 generation = generation.invalidated() 86 guard generation.isActive else { return } 87 let requested = generation 88 task = Task { [weak self] in 89 var attempt: UInt32 = 0 90 while self?.isCurrent(requested) == true { 91 state(.subscribing(attempt: attempt == .max ? .max : attempt + 1)) 92 var message = TeraUserMessages.text(.runtimeObservationUnavailable) 93 do { 94 let changes = try await client.changes(bufferCapacity: buffer.capacity) 95 guard self?.isCurrent(requested) == true else { break } 96 state(.active) 97 invalidate(.currentState) 98 self?.requireCurrentState(requested, refresh: refresh) 99 for await value in changes { 100 guard self?.isCurrent(requested) == true else { break } 101 attempt = 0 102 if accepts(value) { 103 var changed = TeraObservationBatch() 104 changed.insert(value) 105 invalidate(changed) 106 self?.pending.insert(value) 107 self?.startRefresh(requested, refresh: refresh) 108 } 109 } 110 } catch { 111 message = TeraUserMessages.text(for: error, fallback: .runtimeObservationUnavailable) 112 } 113 guard self?.isCurrent(requested) == true else { break } 114 attempt = attempt == .max ? .max : attempt + 1 115 state(.retrying(attempt: attempt, message: message)) 116 do { try await buffer.delay(attempt) } catch { break } 117 } 118 self?.finish(requested, state: state) 119 } 120 } 121 122 private func requireCurrentState( 123 _ requested: TeraSessionGeneration, 124 refresh: @escaping @MainActor (TeraObservationBatch) async -> Void 125 ) { 126 pending = .currentState 127 startRefresh(requested, refresh: refresh) 128 } 129 130 private func startRefresh( 131 _ requested: TeraSessionGeneration, 132 refresh: @escaping @MainActor (TeraObservationBatch) async -> Void 133 ) { 134 guard refreshTask == nil, !pending.isEmpty, isCurrent(requested) else { return } 135 refreshTask = Task { [weak self] in 136 while let batch = self?.takePending(requested) { 137 await refresh(batch) 138 } 139 guard self?.generation == requested else { return } 140 self?.refreshTask = nil 141 } 142 } 143 144 private func takePending(_ requested: TeraSessionGeneration) -> TeraObservationBatch? { 145 guard isCurrent(requested), !pending.isEmpty else { return nil } 146 let batch = pending 147 pending = TeraObservationBatch() 148 return batch 149 } 150 151 private func finish( 152 _ requested: TeraSessionGeneration, state: @MainActor (TeraRuntimeObservationState) -> Void 153 ) { 154 guard generation == requested else { return } 155 let cancelled = Task.isCancelled 156 stop() 157 if cancelled { 158 state(.stopped) 159 } 160 } 161 162 private func isCurrent(_ requested: TeraSessionGeneration) -> Bool { 163 generation == requested && generation.isActive && !Task.isCancelled 164 } 165 }