admin/LehrerApp
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

fix: Pull-Wasserzeichen sprang über fremde Ereignisse + schärfere Push-Kollisionskontrolle

Browse Source 
EventStore.Pull gab bisher den globalen ServerSeq-Höchststand als neuen Cursor zurück statt
den höchsten unter den tatsächlich gelieferten Ereignissen - hatte ein Gerät selbst kurz zuvor
etwas gepusht, sprang sein Pull-Cursor über noch nicht abgeholte Ereignisse anderer Geräte
hinweg und verpasste sie dauerhaft, ohne jeden Fehler.

Ersetzt außerdem die bisherige 30-Sekunden-Heuristik zur Konflikterkennung beim Push durch
exakte BasedOnServerSeq-Prüfung: jedes SyncEvent trägt die ServerSeq, auf der es aufbaut: der
Server lehnt ab, wenn der aktuelle Stand nicht mehr passt. Bei Ablehnung lädt der Client sofort
den neuen Server-Stand nach, löst den Konflikt nach der bestehenden Desktop-vs-Companion/
Timestamp-Politik auf und macht ihn immer in der Konflikt-Review-UI sichtbar, statt die
verworfene Änderung stillschweigend zu verlieren.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
admin
2026-08-18 23:25:04 +02:00
co-authored by Claude Sonnet 5
parent 270c4d40cd
commit 5bd6967421
13 changed files with 704 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files
LehrerApp.Sync/SyncEngine.cs
+88 -1
View File
@@ -76,8 +76,13 @@ public class SyncEngine : IDisposable
private async Task<(int Pushed, int Conflicts)> PushAsync()
{
var pending = _queue.GetPending();
var pending = DeduplicatePending();
if (pending.Count == 0) return (0, 0);
// BasedOnServerSeq erst unmittelbar vor dem Senden setzen (nicht beim Enqueue) - zwischen
// Enqueue und Push kann ein Pull den lokal bekannten Stand dieser Entität aktualisiert
// haben (siehe EventApplier.ApplyAsync).
foreach (var evt in pending)
evt.BasedOnServerSeq = _queue.GetKnownServerSeq(evt.EntityType, evt.EntityId);
_logger?.Info($"Sync: Push - {pending.Count} Ereignis(se) ausstehend: " +
string.Join(", ", pending.Select(e => $"{e.EntityType}/{e.Operation}")));
var resp = await _http.PostAsJsonAsync("/api/sync/push", pending);
@@ -87,13 +92,95 @@ public class SyncEngine : IDisposable
_queue.Acknowledge(pending
.Where(e => !result.ConflictingEventIds.Contains(e.EventId))
.Select(e => e.EventId));
foreach (var evt in pending)
if (result.AssignedServerSeqs.TryGetValue(evt.EventId, out var seq))
_queue.SetKnownServerSeq(evt.EntityType, evt.EntityId, seq);
_queue.SetLastServerSeq(result.ServerSequenceNr);
_logger?.Info($"Sync: Push - vom Server bestätigt bis ServerSequenceNr={result.ServerSequenceNr}, " +
$"{result.ConflictingEventIds.Count} vom Server abgelehnt (Konflikt).");
if (result.ConflictingEventIds.Count > 0)
await HandleRejectedAsync(pending.Where(e => result.ConflictingEventIds.Contains(e.EventId)));
return (pending.Count - result.ConflictingEventIds.Count,
result.ConflictingEventIds.Count);
}
// Payload ist immer ein vollständiges Entitäts-Snapshot (nie ein Delta, siehe
// SyncEventPublisher) - mehrere ausstehende lokale Änderungen derselben Entität lassen sich
// deshalb gefahrlos auf das jüngste zusammenfassen, bevor gepusht wird. Wichtig auch für die
// exakte BasedOnServerSeq-Prüfung: ohne Dedup könnten zwei Ereignisse derselben Entität im
// selben Batch mit demselben (veralteten) BasedOnServerSeq ankommen und sich gegenseitig ins
// Aus laufen.
private List<SyncEvent> DeduplicatePending()
{
var pending = _queue.GetPending();
if (pending.Count == 0) return pending;
var latest = pending
.GroupBy(e => (e.EntityType, e.EntityId))
.Select(g => g.OrderBy(e => e.SequenceNr).Last())
.ToList();
var superseded = pending.Except(latest).Select(e => e.EventId).ToList();
if (superseded.Count > 0)
{
_queue.Acknowledge(superseded);
_logger?.Info($"Sync: Push - {superseded.Count} veraltete Ereignis(se) derselben " +
"Entität lokal zusammengefasst (Full-Snapshot).");
}
return latest;
}
/// <summary>
/// Ein Push wurde abgelehnt, weil der Server für diese Entität bereits einen neueren Stand
/// hat (BasedOnServerSeq-Mismatch). Lädt den aktuellen Server-Stand sofort nach (statt auf
/// den nächsten regulären Pull zu warten), löst den Konflikt nach derselben Politik wie
/// <see cref="ConflictResolver"/> auf und legt in jedem Fall einen ConflictEntry an, damit der
/// Nutzer sieht, dass hier bereits neuere Daten vorlagen - unabhängig davon, ob die lokale
/// Änderung verworfen wird oder nicht.
/// </summary>
private async Task HandleRejectedAsync(IEnumerable<SyncEvent> rejected)
{
foreach (var local in rejected)
{
SyncEvent? remote;
try
{
remote = await _http.GetFromJsonAsync<SyncEvent>(
$"/api/sync/entity/{local.EntityType}/{local.EntityId}");
}
catch (Exception ex)
{
_logger?.Error($"Sync: Push-Konflikt bei {local.EntityType}/{local.EntityId} - " +
"aktueller Server-Stand konnte nicht nachgeladen werden.", ex);
continue;
}
if (remote is null)
{
_logger?.Warn($"Sync: Push-Konflikt bei {local.EntityType}/{local.EntityId}, aber " +
"kein Server-Stand gefunden - übersprungen.");
continue;
}
_queue.SetKnownServerSeq(local.EntityType, local.EntityId, remote.SequenceNr);
var winner = ConflictResolver.DetermineWinner(local, remote);
_queue.AddConflict(new ConflictEntry
{
LocalEvent = local,
RemoteEvent = remote,
Resolution = winner == local ? "LocalWon" : "RemoteWon",
});
_logger?.Info($"Sync: Push-Konflikt bei {local.EntityType}/{local.EntityId} aufgelöst - " +
$"Server hatte bereits neueren Stand (ServerSeq={remote.SequenceNr}), " +
$"Auflösung={(winner == local ? "LocalWon" : "RemoteWon")}.");
if (winner == remote)
{
await _applier.ApplyAsync(remote);
_queue.Acknowledge([local.EventId]);
}
// LocalWon: Ereignis bleibt unbestätigt in der Queue - der nächste PushAsync-Lauf
// versucht es erneut, jetzt mit dem soeben aktualisierten BasedOnServerSeq.
}
}
private async Task<(int Pulled, int Conflicts)> PullAsync()
{
var since = _queue.GetLastServerSeq();