Baustein 5: EventApplier (Inbound Apply) + Loop-Prevention (Kapitel 10)
Die zentrale, bisher komplett fehlende Luecke: selbst mit Baustein 1-4 haette SyncEngine.PullAsync empfangene Ereignisse nur zur Konflikterkennung genutzt, nie in die lokale LiteDB geschrieben - ankommende Aenderungen von anderen Geraeten waeren nirgends sichtbar geworden. Neu EventApplier: entschluesselt, dispatcht ueber eine explizite EntityType-Tabelle, schreibt IMMER direkt auf die rohe LiteDB- Collection, nie ueber eine Repository-Save/Delete-Methode - sonst wuerde der OnChange-Hook (Baustein 2) die gerade angewendete Aenderung als neues ausgehendes Ereignis re-enqueuen (Sync-Ping-Pong). Ein gemeinsames Suppress-Flag wurde geprueft und verworfen: SyncEngine laeuft per Timer nebenlaeufig zum UI-Thread, ein Flag koennte einen echten Nutzer-Save waehrenddessen verschlucken. Der direkte Collection- Zugriff ist zustandslos und dadurch korrekt. Kaskaden-Faelle nutzen dieselben internen LiteDbContext-Hilfsmethoden wie die Repositories (Baustein 4). Neu SyncEventPublisher, der den OnChange-Hook in ein verschluesseltes EventQueue.Enqueue uebersetzt (an LiteDbContext.OnChange gehaengt). Mit dediziertem Loop-Prevention-Test abgesichert: belegt mit echtem LiteDbContext + OnChange-Zaehler, dass Apply keinen neuen Hook-Aufruf ausloest. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
Claude Sonnet 5
@@ -0,0 +1,112 @@
|
||||
using System.Text;
|
||||
using JsonSerializer = System.Text.Json.JsonSerializer;
|
||||
using LehrerApp.Core.Models;
|
||||
using LehrerApp.Data;
|
||||
using LehrerApp.Sync.Crypto;
|
||||
using LehrerApp.Sync.Models;
|
||||
using LiteDB;
|
||||
|
||||
namespace LehrerApp.Sync;
|
||||
|
||||
/// <summary>
|
||||
/// Wendet ein von <see cref="SyncEngine"/> empfangenes (und nicht durch einen Konflikt
|
||||
/// verlorenes) Ereignis auf die lokale Datenbank an.
|
||||
///
|
||||
/// Schreibt IMMER direkt auf die rohe LiteDB-Collection, nie über eine Repository-
|
||||
/// Save/Delete-Methode — sonst würde <see cref="LiteDbContext.OnChange"/> erneut feuern und die
|
||||
/// gerade angewendete Änderung als neues ausgehendes Ereignis re-enqueuen (Sync-Ping-Pong).
|
||||
/// Ein gemeinsames Suppress-Flag wurde bewusst verworfen: SyncEngine läuft per Timer nebenläufig
|
||||
/// zum UI-Thread, ein Flag könnte während eines laufenden Pulls einen echten Nutzer-Save
|
||||
/// verschlucken. Der direkte Collection-Zugriff ist zustandslos und dadurch korrekt.
|
||||
///
|
||||
/// Weiche Geschäftsregeln (z.B. ArchivedGroupWriteGuard, Namens-Eindeutigkeit) werden auf diesem
|
||||
/// Pfad bewusst NICHT geprüft (v1-Einschränkung, siehe TODO.md 10.3) — nur harte LiteDB-Unique-
|
||||
/// Constraints greifen noch und führen zum Überspringen des einzelnen Ereignisses.
|
||||
/// </summary>
|
||||
public class EventApplier(LiteDbContext db, byte[] syncKey)
|
||||
{
|
||||
private static readonly Dictionary<string, EntityHandler> Handlers = BuildHandlers();
|
||||
|
||||
public void Apply(SyncEvent evt)
|
||||
{
|
||||
if (!Handlers.TryGetValue(evt.EntityType, out var handler)) return;
|
||||
try
|
||||
{
|
||||
var json = evt.Payload.Length == 0 ? "" : Decrypt(evt.Payload);
|
||||
handler(db, evt.Operation, evt.EntityId, json);
|
||||
}
|
||||
catch (LiteException)
|
||||
{
|
||||
// Harte Constraint-Verletzung (z.B. Unique-Index) - dieses eine Ereignis
|
||||
// überspringen, statt den gesamten Sync-Lauf abzubrechen.
|
||||
}
|
||||
}
|
||||
|
||||
private string Decrypt(string payloadBase64) =>
|
||||
Encoding.UTF8.GetString(SyncCrypto.Decrypt(Convert.FromBase64String(payloadBase64), syncKey));
|
||||
|
||||
private delegate void EntityHandler(LiteDbContext db, string operation, string entityId, string json);
|
||||
|
||||
private static Dictionary<string, EntityHandler> BuildHandlers()
|
||||
{
|
||||
var handlers = new Dictionary<string, EntityHandler>();
|
||||
|
||||
void Simple<T>(Func<LiteDbContext, ILiteCollection<T>> collection) where T : class =>
|
||||
handlers[typeof(T).Name] = (context, operation, entityId, json) =>
|
||||
{
|
||||
if (operation == "Delete") collection(context).Delete(new Guid(entityId));
|
||||
else collection(context).Upsert(JsonSerializer.Deserialize<T>(json)!);
|
||||
};
|
||||
|
||||
Simple<Student>(context => context.Students);
|
||||
Simple<SeatingPlan>(context => context.SeatingPlans);
|
||||
Simple<GroupMembership>(context => context.Memberships);
|
||||
Simple<GradingKeyTemplate>(context => context.GradingKeyTemplates);
|
||||
Simple<Grade>(context => context.Grades);
|
||||
Simple<GradingScheme>(context => context.GradingSchemes);
|
||||
Simple<ReportGrade>(context => context.ReportGrades);
|
||||
Simple<Unit>(context => context.Units);
|
||||
Simple<Lesson>(context => context.Lessons);
|
||||
Simple<WorkTask>(context => context.Tasks);
|
||||
Simple<TimeEntry>(context => context.TimeEntries);
|
||||
Simple<ExamResult>(context => context.ExamResults);
|
||||
Simple<ParticipationEntry>(context => context.ParticipationEntries);
|
||||
Simple<ParticipationAspect>(context => context.ParticipationAspects);
|
||||
Simple<ParticipationSection>(context => context.ParticipationSections);
|
||||
Simple<Subject>(context => context.Subjects);
|
||||
Simple<ShorthandCode>(context => context.ShorthandCodes);
|
||||
Simple<AlternativeLessonPath>(context => context.AlternativeLessonPaths);
|
||||
Simple<TimetableSlot>(context => context.TimetableSlots);
|
||||
Simple<SchoolHoliday>(context => context.SchoolHolidays);
|
||||
Simple<SupervisionDuty>(context => context.SupervisionDuties);
|
||||
Simple<SubstitutionEntry>(context => context.SubstitutionEntries);
|
||||
Simple<CompetencyDomain>(context => context.CompetencyDomains);
|
||||
|
||||
// Kaskaden-Fälle: dieselben internen LiteDbContext-Hilfsmethoden wie die jeweiligen
|
||||
// Repositories, damit die Kaskade nur an einer Stelle im Code existiert.
|
||||
handlers[nameof(LearningGroup)] = (context, operation, entityId, json) =>
|
||||
{
|
||||
if (operation == "Delete") context.CascadeDeleteGroup(new Guid(entityId));
|
||||
else context.Groups.Upsert(JsonSerializer.Deserialize<LearningGroup>(json)!);
|
||||
};
|
||||
handlers[nameof(Exam)] = (context, operation, entityId, json) =>
|
||||
{
|
||||
if (operation == "Delete") context.CascadeDeleteExam(new Guid(entityId));
|
||||
else context.Exams.Upsert(JsonSerializer.Deserialize<Exam>(json)!);
|
||||
};
|
||||
handlers[nameof(ParticipationSession)] = (context, operation, entityId, json) =>
|
||||
{
|
||||
if (operation == "Delete") context.CascadeDeleteParticipationSession(new Guid(entityId));
|
||||
else context.ParticipationSessions.Upsert(JsonSerializer.Deserialize<ParticipationSession>(json)!);
|
||||
};
|
||||
// "Delete" ist hier das harte Löschen (samt Anhängen) - das weiche Löschen kommt als
|
||||
// "Save" mit IsDeleted=true und läuft über den generischen Upsert-Zweig.
|
||||
handlers[nameof(Documentation)] = (context, operation, entityId, json) =>
|
||||
{
|
||||
if (operation == "Delete") context.CascadeHardDeleteDocumentation(new Guid(entityId));
|
||||
else context.Documentation.Upsert(JsonSerializer.Deserialize<Documentation>(json)!);
|
||||
};
|
||||
|
||||
return handlers;
|
||||
}
|
||||
}
|
||||
@@ -11,6 +11,7 @@ public class SyncEngine : IDisposable
|
||||
{
|
||||
private readonly EventQueue _queue;
|
||||
private readonly ConflictResolver _resolver;
|
||||
private readonly EventApplier _applier;
|
||||
private readonly HttpClient _http;
|
||||
private readonly SyncConfig _config;
|
||||
private readonly Timer _timer;
|
||||
@@ -18,11 +19,12 @@ public class SyncEngine : IDisposable
|
||||
public SyncStatus Status { get; private set; } = new();
|
||||
public event Action<SyncStatus>? StatusChanged;
|
||||
|
||||
public SyncEngine(EventQueue queue, ConflictResolver resolver,
|
||||
public SyncEngine(EventQueue queue, ConflictResolver resolver, EventApplier applier,
|
||||
HttpClient http, SyncConfig config)
|
||||
{
|
||||
_queue = queue;
|
||||
_resolver = resolver;
|
||||
_applier = applier;
|
||||
_http = http;
|
||||
_config = config;
|
||||
_timer = new Timer(
|
||||
@@ -75,7 +77,10 @@ public class SyncEngine : IDisposable
|
||||
foreach (var evt in resp.Events)
|
||||
{
|
||||
var c = _resolver.TryResolve(evt, _config.DeviceId);
|
||||
if (c is not null) { _queue.AddConflict(c); conflicts++; }
|
||||
if (c is null) { _applier.Apply(evt); continue; }
|
||||
_queue.AddConflict(c);
|
||||
conflicts++;
|
||||
if (c.Resolution == "RemoteWon") _applier.Apply(evt);
|
||||
}
|
||||
_queue.SetLastServerSeq(resp.ServerSequenceNr);
|
||||
return (resp.Events.Count, conflicts);
|
||||
|
||||
@@ -0,0 +1,19 @@
|
||||
using LehrerApp.Data;
|
||||
using LehrerApp.Sync.Crypto;
|
||||
using LehrerApp.Sync.Models;
|
||||
|
||||
namespace LehrerApp.Sync;
|
||||
|
||||
/// <summary>
|
||||
/// Wandelt <see cref="LiteDbContext.OnChange"/>-Aufrufe in ausgehende Sync-Ereignisse um. Wird in
|
||||
/// AppBootstrapper an <see cref="LiteDbContext.OnChange"/> gehängt, wenn Sync konfiguriert ist —
|
||||
/// dort entsteht aus den ~27 Repository-Aufrufen genau ein verschlüsseltes Ereignis pro Aufruf.
|
||||
/// </summary>
|
||||
public class SyncEventPublisher(EventQueue queue, string deviceId, byte[] syncKey)
|
||||
{
|
||||
public void Publish(string entityType, string entityId, string operation, object? payload)
|
||||
{
|
||||
var encrypted = payload is null ? "" : SyncCrypto.EncryptObject(payload, syncKey);
|
||||
queue.Enqueue(deviceId, DeviceType.Desktop, entityType, entityId, operation, encrypted);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user