Crossmate/Sync/RecordApplier.swift (35650B)
1import CloudKit
2import CoreData
3import Foundation
4
5struct BatchEffects {
6 var movesUpdated = Set<UUID>()
7
8
9
10
11
12
13
14
15
16 var rosterRelevant = Set<UUID>()
17 var pings: [Ping] = []
18 var playersUpdated = Set<UUID>()
19 var playerPresenceChanged = Set<UUID>()
20 var engagementChanged = Set<UUID>()
21
22
23 var contentKeysChanged = Set<UUID>()
24
25
26
27
28
29 var staleCredentialRecords = Set<String>()
30
31
32
33
34
35 var credentialRotations = Set<UUID>()
36 var removed = Set<UUID>()
37
38
39
40
41 var readCursors: [(UUID, Date, Date?)] = []
42
43
44
45 var completedTransitions = Set<UUID>()
46
47
48 var journalsSynced = Set<UUID>()
49
50 var accountPushAddresses: [String] = []
51
52
53
54
55 var accountPushSecrets: [(secret: String, version: Int64)] = []
56
57
58
59 var selfNameVersions: [Int64] = []
60
61
62
63 var friendNamesChanged = false
64
65
66
67 var blockedFriendAuthorIDs = Set<String>()
68
69
70
71
72 var visibilityCandidateGameIDs = Set<UUID>()
73
74
75
76
77
78
79
80 var traces: [String] = []
81}
82
83extension SyncEngine {
84 func applyDirectRecordZoneChanges(
85 records: [CKRecord],
86 deletions: [(CKRecord.ID, CKRecord.RecordType)],
87 scopeValue: DatabaseScope
88 ) async {
89 guard !records.isEmpty || !deletions.isEmpty else { return }
90 let ctx = persistence.container.newBackgroundContext()
91 ctx.mergePolicy = NSMergePolicy.mergeByPropertyObjectTrump
92 let localAuthorID = await currentLocalAuthorID()
93 let effects: BatchEffects = await ctx.perform {
94 var effects = BatchEffects()
95 for record in records {
96 guard !RecordSerializer.isGameScopedRecordType(record.recordType)
97 || RecordSerializer.isTrustedGameScopedRecord(record)
98 else {
99 effects.traces.append(
100 "rejected untrusted direct record \(record.recordType) " +
101 "\(record.recordID.recordName) in \(record.recordID.zoneID.zoneName)"
102 )
103 continue
104 }
105 switch record.recordType {
106 case "Game":
107 let entity = RecordSerializer.applyGameRecord(
108 record,
109 to: ctx,
110 databaseScope: scopeValue,
111 onEngagementChange: { effects.engagementChanged.insert($0) },
112 onCompletedTransition: { effects.completedTransitions.insert($0) },
113 onContentKeyChange: { effects.contentKeysChanged.insert($0) },
114 onStaleCredentials: { effects.staleCredentialRecords.insert($0) },
115 onDiagnostic: { effects.traces.append($0) }
116 )
117 if let id = entity.id {
118 effects.rosterRelevant.insert(id)
119 effects.visibilityCandidateGameIDs.insert(id)
120 }
121 case "Moves":
122 if let value = RecordSerializer.parseMovesRecord(record) {
123 effects.visibilityCandidateGameIDs.insert(value.gameID)
124 let cellsChanged = RecordSerializer.applyMovesRecord(
125 record,
126 value: value,
127 to: ctx,
128 databaseScope: scopeValue,
129 localAuthorID: localAuthorID,
130 onNewAuthor: { _ in effects.rosterRelevant.insert(value.gameID) }
131 )
132 if cellsChanged { effects.movesUpdated.insert(value.gameID) }
133 }
134 case "Player":
135 if let (gameID, _) = RecordSerializer.parsePlayerRecordName(record.recordID.recordName) {
136 effects.visibilityCandidateGameIDs.insert(gameID)
137 self.applyPlayerRecord(
138 record,
139 in: ctx,
140 databaseScope: scopeValue,
141 localAuthorID: localAuthorID,
142 onFirstTime: { effects.playersUpdated.insert($0) },
143 onPresenceChange: { effects.playerPresenceChanged.insert($0) },
144 onReadCursor: { effects.readCursors.append(($0, $1, $2)) }
145 )
146 effects.rosterRelevant.insert(gameID)
147 }
148 case Archive.recordType, Archive.legacyRecordType:
149 if let id = self.applyArchiveRecord(
150 record,
151 in: ctx,
152 onDiagnostic: { effects.traces.append($0) }
153 ) {
154 effects.rosterRelevant.insert(id)
155 effects.visibilityCandidateGameIDs.insert(id)
156 }
157 default:
158 break
159 }
160 }
161 for deletion in deletions {
162 guard !RecordSerializer.isGameScopedRecordType(deletion.1)
163 || RecordSerializer.isTrustedGameScopedDeletion(
164 recordID: deletion.0,
165 recordType: deletion.1
166 )
167 else {
168 effects.traces.append(
169 "rejected untrusted direct deletion \(deletion.1) " +
170 "\(deletion.0.recordName) in \(deletion.0.zoneID.zoneName)"
171 )
172 continue
173 }
174 self.applyDeletion(
175 recordID: deletion.0,
176 recordType: deletion.1,
177 databaseScope: scopeValue,
178 in: ctx
179 )
180 if let id = self.gameID(fromRecordName: deletion.0.recordName) {
181 effects.rosterRelevant.insert(id)
182 effects.visibilityCandidateGameIDs.insert(id)
183 }
184 }
185 for gameID in effects.movesUpdated {
186 effects.traces += self.replayCellCache(for: gameID, in: ctx)
187 }
188 if ctx.hasChanges {
189 do {
190 try ctx.save()
191 } catch {
192 let nsError = error as NSError
193 effects.traces.append(
194 "direct-push ctx.save FAILED " +
195 "— domain=\(nsError.domain) code=\(nsError.code) " +
196 "\(nsError.localizedDescription)"
197 )
198 }
199 }
200
201
202 if !effects.contentKeysChanged.isEmpty {
203 GameEntity.rebuildContentKeyDirectory(in: ctx)
204 }
205 return effects
206 }
207
208 for message in effects.traces {
209 await trace(message)
210 }
211 if let onGameVisibilityCandidates, !effects.visibilityCandidateGameIDs.isEmpty {
212 await onGameVisibilityCandidates(effects.visibilityCandidateGameIDs)
213 }
214 if let onRemoteMovesUpdated, !effects.movesUpdated.isEmpty {
215 await onRemoteMovesUpdated(effects.movesUpdated)
216 }
217 if let onRemotePlayersUpdated, !effects.playersUpdated.isEmpty {
218 await onRemotePlayersUpdated(effects.playersUpdated)
219 }
220 if let onRemotePlayerPresenceChanged, !effects.playerPresenceChanged.isEmpty {
221 await onRemotePlayerPresenceChanged(effects.playerPresenceChanged)
222 }
223 if let onRemoteEngagementChanged, !effects.engagementChanged.isEmpty {
224 await onRemoteEngagementChanged(effects.engagementChanged)
225 }
226 if let onIncomingReadCursor, !effects.readCursors.isEmpty {
227 await onIncomingReadCursor(effects.readCursors)
228 }
229
230
231
232 if let localAuthorID, !localAuthorID.isEmpty {
233 for id in effects.completedTransitions {
234 enqueueJournalUpload(gameID: id, authorID: localAuthorID)
235 }
236 }
237 if let onGameCompleted {
238 for id in effects.completedTransitions {
239 await onGameCompleted(id)
240 }
241 }
242 let deletedPings = deletions.compactMap { deletion -> (recordName: String, gameID: UUID)? in
243 let recordName = deletion.0.recordName
244 guard recordName.hasPrefix("ping-"),
245 let gameID = gameID(fromRecordName: recordName)
246 else { return nil }
247 return (recordName, gameID)
248 }
249 if let onPingDeleted, !deletedPings.isEmpty {
250 await onPingDeleted(deletedPings)
251 }
252 if !effects.rosterRelevant.isEmpty {
253 NotificationCenter.default.post(
254 name: .playerRosterShouldRefresh,
255 object: nil,
256 userInfo: ["gameIDs": effects.rosterRelevant]
257 )
258 }
259
260
261
262 for recordName in effects.staleCredentialRecords {
263 enqueueGame(ckRecordName: recordName)
264 }
265 if let onRemoteCredentialsChanged, !effects.contentKeysChanged.isEmpty {
266 await onRemoteCredentialsChanged(effects.contentKeysChanged)
267 }
268 }
269
270 nonisolated func applyPlayerRecord(
271 _ record: CKRecord,
272 in ctx: NSManagedObjectContext,
273 databaseScope: DatabaseScope = .private,
274 localAuthorID: String?,
275 onFirstTime: (UUID) -> Void,
276 onPresenceChange: (UUID) -> Void,
277 onReadCursor: (UUID, Date, Date?) -> Void
278 ) {
279 let ckName = record.recordID.recordName
280 guard let (gameID, authorID) = RecordSerializer.parsePlayerRecordName(ckName) else {
281 return
282 }
283 let renderedName = record["name"] as? String
284 let updatedAt = record["updatedAt"] as? Date
285 ?? record.modificationDate
286 ?? Date()
287
288 let req = NSFetchRequest<PlayerEntity>(entityName: "PlayerEntity")
289 req.predicate = RecordSerializer.gameIdentityPredicate(
290 recordName: ckName,
291 zoneID: record.recordID.zoneID,
292 databaseScope: databaseScope,
293 entityPrefix: "game"
294 )
295 req.fetchLimit = 1
296
297 let entity: PlayerEntity
298 let foundExisting: Bool
299 if let existing = try? ctx.fetch(req).first {
300 entity = existing
301 foundExisting = true
302 } else {
303 let game = RecordSerializer.ensureGameEntity(
304 forGameID: gameID,
305 zoneID: record.recordID.zoneID,
306 databaseScope: databaseScope,
307 in: ctx
308 )
309 entity = PlayerEntity(context: ctx)
310 entity.game = game
311 foundExisting = false
312 }
313
314
315
316
317
318
319 if foundExisting,
320 !RecordSerializer.incomingIsAtLeastAsFresh(record, existingFields: entity.ckSystemFields) {
321 return
322 }
323
324 let oldSelection = (entity.selRow, entity.selCol, entity.selDir)
325 let hadSelection = oldSelection.0 != nil && oldSelection.1 != nil && oldSelection.2 != nil
326 let oldUpdatedAt = entity.updatedAt
327
328
329
330 entity.ckRecordName = ckName
331 entity.ckSystemFields = RecordSerializer.encodeSystemFields(of: record)
332 entity.authorID = authorID
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354 let previousPresenceUntil = entity.presenceUntil
355 let previousViewedAt = entity.viewedAt
356 let incomingPresenceUntil = RecordSerializer.parsePlayerPresenceUntil(from: record)
357 entity.presenceUntil = incomingPresenceUntil
358 let incomingReadThrough = RecordSerializer.parsePlayerReadThrough(from: record)
359 entity.readThrough = incomingReadThrough
360 entity.viewedAt = RecordSerializer.parsePlayerViewedAt(from: record)
361
362
363
364
365
366
367
368
369 if record.allKeys().contains("timeLog") {
370 let incomingTimeLog = RecordSerializer.parsePlayerTimeLog(from: record)
371 if authorID == localAuthorID {
372
373
374
375 var local = TimeLog.decode(entity.timeLog)
376 local.merge(
377 inbound: TimeLog.decode(incomingTimeLog),
378 preservingDevice: RecordSerializer.localDeviceID
379 )
380 entity.timeLog = local.devices.isEmpty ? nil : TimeLog.encode(local)
381 } else {
382 entity.timeLog = incomingTimeLog
383 }
384 }
385
386
387
388
389
390
391 if authorID == localAuthorID, let presenceUntil = incomingPresenceUntil,
392 presenceUntil != previousPresenceUntil || entity.viewedAt != previousViewedAt {
393 onReadCursor(gameID, presenceUntil, entity.viewedAt)
394 }
395
396
397
398
399 if authorID == localAuthorID,
400 let incomingReadThrough,
401 let game = entity.game,
402 (game.readThroughAt ?? .distantPast) < incomingReadThrough {
403 game.readThroughAt = incomingReadThrough
404 let archiveRequest = NSFetchRequest<GameEntity>(entityName: "GameEntity")
405 archiveRequest.predicate = NSPredicate(
406 format: "id == %@",
407 Archive.archiveGameID(for: gameID) as CVarArg
408 )
409 archiveRequest.fetchLimit = 1
410 if let chronicle = try? ctx.fetch(archiveRequest).first {
411 Archive.mirrorReadState(from: game, to: chronicle)
412 }
413 }
414
415
416
417
418
419 let localUpdatedAt = entity.updatedAt
420 let incomingIsFresher = localUpdatedAt.map { updatedAt >= $0 } ?? true
421 guard incomingIsFresher else { return }
422
423
424
425 if let renderedName, !renderedName.isEmpty {
426 entity.name = renderedName
427 }
428 entity.updatedAt = updatedAt
429
430
431 if let selection = RecordSerializer.parsePlayerSelection(from: record),
432 GridPosition(row: selection.row, col: selection.col).isPersistable(
433 gridWidth: entity.game?.gridWidth ?? 0,
434 gridHeight: entity.game?.gridHeight ?? 0
435 ) {
436 entity.selRow = NSNumber(value: Int64(selection.row))
437 entity.selCol = NSNumber(value: Int64(selection.col))
438 entity.selDir = NSNumber(value: Int64(selection.direction.rawValue))
439 } else {
440 entity.selRow = nil
441 entity.selCol = nil
442 entity.selDir = nil
443 }
444
445
446
447
448 entity.pushAddress = RecordSerializer.parsePlayerPushAddress(from: record)
449 let isRemoteAuthor = authorID != localAuthorID && authorID != CKCurrentUserDefaultName
450 let hasSelection = entity.selRow != nil && entity.selCol != nil && entity.selDir != nil
451 if isRemoteAuthor,
452 (hadSelection || hasSelection),
453 oldUpdatedAt != entity.updatedAt ||
454 oldSelection.0 != entity.selRow ||
455 oldSelection.1 != entity.selCol ||
456 oldSelection.2 != entity.selDir {
457 onPresenceChange(gameID)
458 }
459 if !foundExisting {
460 onFirstTime(gameID)
461 }
462 }
463
464
465
466
467
468
469
470 nonisolated func replayCellCache(
471 for gameID: UUID,
472 in ctx: NSManagedObjectContext
473 ) -> [String] {
474 let gameReq = NSFetchRequest<GameEntity>(entityName: "GameEntity")
475 gameReq.predicate = NSPredicate(format: "id == %@", gameID as CVarArg)
476 gameReq.fetchLimit = 1
477 let game: GameEntity?
478 do {
479 game = try ctx.fetch(gameReq).first
480 } catch {
481
482
483
484
485 return [Self.syncErrorMessage("replayCellCache game fetch", gameID: gameID, error: error)]
486 }
487 guard let game else { return [] }
488
489 let movesReq = NSFetchRequest<MovesEntity>(entityName: "MovesEntity")
490 movesReq.predicate = NSPredicate(format: "game == %@", game)
491 let movesEntities: [MovesEntity]
492 do {
493 movesEntities = try ctx.fetch(movesReq)
494 } catch {
495 return [Self.syncErrorMessage("replayCellCache moves fetch", gameID: gameID, error: error)]
496 }
497 let values: [MovesValue] = movesEntities.compactMap { Self.movesValue(from: $0) }
498 let gridState = GridStateMerger.merge(values)
499
500 let existingCells = (game.cells as? Set<CellEntity>) ?? []
501 var byPosition: [GridPosition: CellEntity] = [:]
502 for cell in existingCells {
503 byPosition[GridPosition(row: Int(cell.row), col: Int(cell.col))] = cell
504 }
505
506
507
508
509
510 var skippedOutOfGrid = 0
511 for (pos, gridCell) in gridState {
512 guard pos.isPersistable(gridWidth: game.gridWidth, gridHeight: game.gridHeight) else {
513 skippedOutOfGrid += 1
514 continue
515 }
516 let cell: CellEntity
517 if let existing = byPosition[pos] {
518 cell = existing
519 } else {
520 cell = CellEntity(context: ctx)
521 cell.game = game
522 cell.row = Int16(pos.row)
523 cell.col = Int16(pos.col)
524 }
525 cell.letter = gridCell.letter
526 cell.markCode = gridCell.mark.code
527 cell.letterAuthorID = gridCell.authorID
528 }
529
530 for (pos, cell) in byPosition where gridState[pos] == nil {
531 cell.letter = ""
532 cell.markCode = 0
533 cell.letterAuthorID = nil
534 }
535 guard skippedOutOfGrid == 0 else {
536 return [
537 "replayCellCache \(gameID.uuidString.prefix(8)): "
538 + "skipped \(skippedOutOfGrid) out-of-grid remote cell(s)"
539 ]
540 }
541 return []
542 }
543
544
545
546
547 nonisolated static func movesValue(from entity: MovesEntity) -> MovesValue? {
548 guard let gameID = entity.game?.id,
549 let authorID = entity.authorID,
550 let deviceID = entity.deviceID,
551 let updatedAt = entity.updatedAt
552 else { return nil }
553 let cells = (entity.cells.flatMap { try? MovesCodec.decode($0) }) ?? [:]
554 return MovesValue(
555 gameID: gameID,
556 authorID: authorID,
557 deviceID: deviceID,
558 cells: cells,
559 updatedAt: updatedAt
560 )
561 }
562
563
564
565
566
567
568 nonisolated static func syncErrorMessage(_ label: String, gameID: UUID, error: Error) -> String {
569 let nsError = error as NSError
570 return "\(label) FAILED for \(gameID.uuidString) " +
571 "— domain=\(nsError.domain) code=\(nsError.code) " +
572 "\(nsError.localizedDescription)"
573 }
574
575
576
577
578
579
580 nonisolated func applyShareRecord(
581 _ share: CKShare,
582 databaseScope: DatabaseScope,
583 in ctx: NSManagedObjectContext
584 ) -> UUID? {
585 let zoneID = share.recordID.zoneID
586 guard zoneID.zoneName.hasPrefix("game-"),
587 let gameID = UUID(uuidString: String(zoneID.zoneName.dropFirst("game-".count)))
588 else { return nil }
589
590
591
592
593
594 let accepted = share.participants
595 .filter { $0.role != .owner && $0.acceptanceStatus == .accepted }
596 .compactMap { $0.userIdentity.userRecordID?.recordName }
597 let departed = Self.applyShareRoster(
598 gameID: gameID,
599 zoneID: zoneID,
600 acceptedParticipants: accepted,
601 databaseScope: databaseScope,
602 in: ctx
603 )
604 return departed ? gameID : nil
605 }
606
607
608
609
610
611
612
613 nonisolated static func applyShareRoster(
614 gameID: UUID,
615 zoneID: CKRecordZone.ID,
616 acceptedParticipants: [String],
617 databaseScope: DatabaseScope,
618 in ctx: NSManagedObjectContext
619 ) -> Bool {
620 let req = NSFetchRequest<GameEntity>(entityName: "GameEntity")
621 req.predicate = RecordSerializer.gameIdentityPredicate(
622 recordName: "game-\(gameID.uuidString)",
623 zoneID: zoneID,
624 databaseScope: databaseScope,
625 entityPrefix: ""
626 )
627 req.fetchLimit = 1
628 guard let entity = try? ctx.fetch(req).first else { return false }
629
630 let current = Set(acceptedParticipants.filter { !$0.isEmpty })
631 let encoded = current.sorted().joined(separator: ",")
632 let priorEncoded = entity.shareParticipants
633 if priorEncoded != encoded {
634 entity.shareParticipants = encoded
635 }
636 guard let priorEncoded, !priorEncoded.isEmpty else { return false }
637 let prior = Set(priorEncoded.split(separator: ",").map(String.init))
638 return !prior.subtracting(current).isEmpty
639 }
640
641
642
643
644
645
646
647 @discardableResult
648 nonisolated func applyArchiveRecord(
649 _ record: CKRecord,
650 in ctx: NSManagedObjectContext,
651 onDiagnostic: ((String) -> Void)? = nil
652 ) -> UUID? {
653 guard let payload = Archive.payload(from: record, onDiagnostic: onDiagnostic)
654 else { return nil }
655
656 let liveReq = NSFetchRequest<GameEntity>(entityName: "GameEntity")
657 liveReq.predicate = NSPredicate(
658 format: "id == %@ AND isAccessRevoked == NO",
659 payload.originalGameID as CVarArg
660 )
661 liveReq.fetchLimit = 1
662 if (try? ctx.fetch(liveReq).first) != nil { return nil }
663
664 let created = Archive.materialize(payload, in: ctx)
665 return created?.id
666 }
667
668
669
670
671
672 @discardableResult
673 nonisolated func applyPreferredArchiveRecord(
674 _ record: CKRecord,
675 in ctx: NSManagedObjectContext,
676 onDiagnostic: ((String) -> Void)? = nil
677 ) -> UUID? {
678 guard let payload = Archive.payload(from: record, onDiagnostic: onDiagnostic),
679 let materialized = Archive.materialize(payload, in: ctx)
680 else { return nil }
681
682 let liveReq = NSFetchRequest<GameEntity>(entityName: "GameEntity")
683 liveReq.predicate = NSPredicate(
684 format: "id == %@ AND isAccessRevoked == NO",
685 payload.originalGameID as CVarArg
686 )
687 liveReq.fetchLimit = 1
688 if let live = try? ctx.fetch(liveReq).first {
689 live.isSupersededByChronicle = true
690 }
691 return materialized.id
692 }
693
694
695
696 nonisolated func applyDeletion(
697 recordID: CKRecord.ID,
698 recordType: CKRecord.RecordType,
699 databaseScope: DatabaseScope,
700 in ctx: NSManagedObjectContext
701 ) {
702 let name = recordID.recordName
703 let entityName: String
704 if name.hasPrefix("moves-") {
705 entityName = "MovesEntity"
706 } else if name.hasPrefix("player-") {
707 entityName = "PlayerEntity"
708 } else if name.hasPrefix("game-") {
709 entityName = "GameEntity"
710 } else {
711 switch recordType {
712 case "Moves": entityName = "MovesEntity"
713 case "Player": entityName = "PlayerEntity"
714 case "Game": entityName = "GameEntity"
715 default: return
716 }
717 }
718 let req = NSFetchRequest<NSManagedObject>(entityName: entityName)
719 let entityPrefix = entityName == "GameEntity" ? "" : "game"
720 req.predicate = RecordSerializer.gameIdentityPredicate(
721 recordName: name,
722 zoneID: recordID.zoneID,
723 databaseScope: databaseScope,
724 entityPrefix: entityPrefix
725 )
726 req.fetchLimit = 1
727 if let obj = try? ctx.fetch(req).first {
728 ctx.delete(obj)
729 }
730 }
731}