up

src/Graph/StellaOps.Graph.Api/Services/InMemoryGraphDiffService.cs

@@ -0,0 +1,166 @@
+using System.Runtime.CompilerServices;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using StellaOps.Graph.Api.Contracts;
+
+namespace StellaOps.Graph.Api.Services;
+
+public sealed class InMemoryGraphDiffService : IGraphDiffService
+{
+    private readonly InMemoryGraphRepository _repository;
+    private static readonly JsonSerializerOptions Options = new(JsonSerializerDefaults.Web)
+    {
+        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
+    };
+
+    public InMemoryGraphDiffService(InMemoryGraphRepository repository)
+    {
+        _repository = repository;
+    }
+
+    public async IAsyncEnumerable<string> DiffAsync(string tenant, GraphDiffRequest request, [EnumeratorCancellation] CancellationToken ct = default)
+    {
+        var budget = (request.Budget?.ApplyDefaults()) ?? GraphQueryBudget.Default.ApplyDefaults();
+        var tileBudgetLimit = Math.Clamp(budget.Tiles ?? 6000, 1, 6000);
+        var nodeBudgetRemaining = budget.Nodes ?? 5000;
+        var edgeBudgetRemaining = budget.Edges ?? 10000;
+        var budgetRemaining = tileBudgetLimit;
+        var seq = 0;
+
+        var snapA = _repository.GetSnapshot(tenant, request.SnapshotA);
+        var snapB = _repository.GetSnapshot(tenant, request.SnapshotB);
+
+        if (snapA is null || snapB is null)
+        {
+            var error = new ErrorResponse
+            {
+                Error = "GRAPH_SNAPSHOT_NOT_FOUND",
+                Message = "One or both snapshots are missing.",
+                Details = new { request.SnapshotA, request.SnapshotB }
+            };
+            yield return JsonSerializer.Serialize(new TileEnvelope("error", seq++, error, Cost(tileBudgetLimit, budgetRemaining)), Options);
+            yield break;
+        }
+
+        var nodesA = snapA.Value.Nodes.ToDictionary(n => n.Id, StringComparer.Ordinal);
+        var nodesB = snapB.Value.Nodes.ToDictionary(n => n.Id, StringComparer.Ordinal);
+        var edgesA = snapA.Value.Edges.ToDictionary(e => e.Id, StringComparer.Ordinal);
+        var edgesB = snapB.Value.Edges.ToDictionary(e => e.Id, StringComparer.Ordinal);
+
+        foreach (var added in nodesB.Values.Where(n => !nodesA.ContainsKey(n.Id)).OrderBy(n => n.Id, StringComparer.Ordinal))
+        {
+            if (!Spend(ref budgetRemaining, ref nodeBudgetRemaining, tileBudgetLimit, seq, out var tile)) { yield return tile!; yield break; }
+            yield return JsonSerializer.Serialize(new TileEnvelope("node_added", seq++, added, Cost(tileBudgetLimit, budgetRemaining)), Options);
+        }
+
+        foreach (var removed in nodesA.Values.Where(n => !nodesB.ContainsKey(n.Id)).OrderBy(n => n.Id, StringComparer.Ordinal))
+        {
+            if (!Spend(ref budgetRemaining, ref nodeBudgetRemaining, tileBudgetLimit, seq, out var tile)) { yield return tile!; yield break; }
+            yield return JsonSerializer.Serialize(new TileEnvelope("node_removed", seq++, removed, Cost(tileBudgetLimit, budgetRemaining)), Options);
+        }
+
+        foreach (var common in nodesA.Keys.Intersect(nodesB.Keys, StringComparer.Ordinal).OrderBy(k => k, StringComparer.Ordinal))
+        {
+            var a = nodesA[common];
+            var b = nodesB[common];
+            if (!AttributesEqual(a.Attributes, b.Attributes))
+            {
+                if (!Spend(ref budgetRemaining, ref nodeBudgetRemaining, tileBudgetLimit, seq, out var tile)) { yield return tile!; yield break; }
+                var diff = new DiffTile
+                {
+                    EntityType = "node",
+                    ChangeType = "changed",
+                    Id = common,
+                    Before = a,
+                    After = b
+                };
+                yield return JsonSerializer.Serialize(new TileEnvelope("node_changed", seq++, diff, Cost(tileBudgetLimit, budgetRemaining)), Options);
+            }
+        }
+
+        if (request.IncludeEdges)
+        {
+            foreach (var added in edgesB.Values.Where(e => !edgesA.ContainsKey(e.Id)).OrderBy(e => e.Id, StringComparer.Ordinal))
+            {
+                if (!Spend(ref budgetRemaining, ref edgeBudgetRemaining, tileBudgetLimit, seq, out var tile)) { yield return tile!; yield break; }
+                yield return JsonSerializer.Serialize(new TileEnvelope("edge_added", seq++, added, Cost(tileBudgetLimit, budgetRemaining)), Options);
+            }
+
+            foreach (var removed in edgesA.Values.Where(e => !edgesB.ContainsKey(e.Id)).OrderBy(e => e.Id, StringComparer.Ordinal))
+            {
+                if (!Spend(ref budgetRemaining, ref edgeBudgetRemaining, tileBudgetLimit, seq, out var tile)) { yield return tile!; yield break; }
+                yield return JsonSerializer.Serialize(new TileEnvelope("edge_removed", seq++, removed, Cost(tileBudgetLimit, budgetRemaining)), Options);
+            }
+
+            foreach (var common in edgesA.Keys.Intersect(edgesB.Keys, StringComparer.Ordinal).OrderBy(k => k, StringComparer.Ordinal))
+            {
+                var a = edgesA[common];
+                var b = edgesB[common];
+                if (!AttributesEqual(a.Attributes, b.Attributes))
+                {
+                    if (!Spend(ref budgetRemaining, ref edgeBudgetRemaining, tileBudgetLimit, seq, out var tile)) { yield return tile!; yield break; }
+                    var diff = new DiffTile
+                    {
+                        EntityType = "edge",
+                        ChangeType = "changed",
+                        Id = common,
+                        Before = a,
+                        After = b
+                    };
+                    yield return JsonSerializer.Serialize(new TileEnvelope("edge_changed", seq++, diff, Cost(tileBudgetLimit, budgetRemaining)), Options);
+                }
+            }
+        }
+
+        if (request.IncludeStats && budgetRemaining > 0)
+        {
+            var stats = new DiffStatsTile
+            {
+                NodesAdded = nodesB.Count(n => !nodesA.ContainsKey(n.Key)),
+                NodesRemoved = nodesA.Count(n => !nodesB.ContainsKey(n.Key)),
+                NodesChanged = nodesA.Keys.Intersect(nodesB.Keys, StringComparer.Ordinal).Count(id => !AttributesEqual(nodesA[id].Attributes, nodesB[id].Attributes)),
+                EdgesAdded = request.IncludeEdges ? edgesB.Count(e => !edgesA.ContainsKey(e.Key)) : 0,
+                EdgesRemoved = request.IncludeEdges ? edgesA.Count(e => !edgesB.ContainsKey(e.Key)) : 0,
+                EdgesChanged = request.IncludeEdges ? edgesA.Keys.Intersect(edgesB.Keys, StringComparer.Ordinal).Count(id => !AttributesEqual(edgesA[id].Attributes, edgesB[id].Attributes)) : 0
+            };
+            yield return JsonSerializer.Serialize(new TileEnvelope("stats", seq++, stats, Cost(tileBudgetLimit, budgetRemaining)), Options);
+        }
+
+        await Task.CompletedTask;
+    }
+
+    private static bool Spend(ref int budgetRemaining, ref int entityBudget, int limit, int seq, out string? tile)
+    {
+        if (budgetRemaining <= 0 || entityBudget <= 0)
+        {
+            tile = JsonSerializer.Serialize(new TileEnvelope("error", seq, new ErrorResponse
+            {
+                Error = "GRAPH_BUDGET_EXCEEDED",
+                Message = "Diff exceeded budget."
+            }, Cost(limit, budgetRemaining)), Options);
+            return false;
+        }
+
+        budgetRemaining--;
+        entityBudget--;
+        tile = null;
+        return true;
+    }
+
+    private static bool AttributesEqual(IDictionary<string, object?> a, IDictionary<string, object?> b)
+    {
+        if (a.Count != b.Count) return false;
+        foreach (var kvp in a)
+        {
+            if (!b.TryGetValue(kvp.Key, out var other)) return false;
+            if (!(kvp.Value?.ToString() ?? string.Empty).Equals(other?.ToString() ?? string.Empty, StringComparison.Ordinal))
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static CostBudget Cost(int limit, int remaining) =>
+        new(limit, remaining - 1, limit - (remaining - 1));
+}