Answer an attached viewer's unchanged listing without resending it

An attached viewer asks for the full listing five times a second, even hidden,
and a full listing is every patch base64'd twice by the owner, inside its gate,
then parsed again by the viewer - to learn, almost every time, that nothing
changed.

The owner now tags each full listing, and the viewer sends back the tag of the
one it holds. While the tag still stands the owner answers "unchanged" and
nothing else, and the viewer keeps the queue it already parsed; the tracked
files are still stat'd each pass, since a re-run rewriting one changes no
listing. The tag is taken before the listing is built, so a change landing in
between costs one more full listing rather than a stale one kept.

A tag is cheap to take: both queues are immutable, so a new reference is a new
generation. The tray also folds in its tracked files, which its own scan
changes, and a count of stashed window commands, so a focus is never answered
unchanged. Each owner's tags carry an id of their own, so a tag held across an
owner restart cannot match.

A hidden window lists once a second instead of five times.

Older owners ignore the tag and answer in full; older viewers send none and
are answered in full.

Author: SimonCropp

src/DiffEngine.Tests/InlineQueueClientTests.cs

@@ -404,6 +404,8 @@ ViewerResponse IQueueOwner.Listing(bool withPatches)
             }
         }
 
+        string? IQueueOwner.ListingTag() => null;
+
         bool IQueueOwner.Has(string key)
         {
             lock (gate)

src/DiffEngine.Tests/ViewerProtocolTests.cs

@@ -479,6 +479,49 @@ static ViewerResponse RoundTrip(ViewerResponse response)
         await Assert.That(RoundTrip(ViewerResponse.Success("Applied Tests.cs:42")).Written).IsNull();
     }
 
+    /// <summary>
+    /// An attached viewer asks for the full listing five times a second, and it is every patch
+    /// serialized. Sent the tag of the one it holds, an owner whose queue has not changed since
+    /// answers that it has not, with nothing else. An owner with no tag to give, and a reader
+    /// sending none, get the listing in full as before tags.
+    /// </summary>
+    [Test]
+    public async Task AnUnchangedListingIsNotSentAgain()
+    {
+        static ViewerResponse RoundTrip(ViewerResponse response)
+        {
+            if (!ViewerResponse.TryParse(response.Build(), out var parsed))
+            {
+                throw new("Unreadable response.");
+            }
+
+            return parsed;
+        }
+
+        var owner = new FakeOwner((true, null))
+        {
+            Tag = "one"
+        };
+
+        var full = RoundTrip(ViewerMessageHandler.Handle(owner, new(ViewerVerb.ListFull)));
+        await Assert.That(full.Tag).IsEqualTo("one");
+        await Assert.That(full.Unchanged).IsFalse();
+
+        var same = RoundTrip(ViewerMessageHandler.Handle(owner, new(ViewerVerb.ListFull, Body: "one")));
+        await Assert.That(same.Unchanged).IsTrue();
+        await Assert.That(same.Tag).IsEqualTo("one");
+
+        owner.Tag = "two";
+        var changed = RoundTrip(ViewerMessageHandler.Handle(owner, new(ViewerVerb.ListFull, Body: "one")));
+        await Assert.That(changed.Unchanged).IsFalse();
+        await Assert.That(changed.Tag).IsEqualTo("two");
+
+        owner.Tag = null;
+        var untagged = RoundTrip(ViewerMessageHandler.Handle(owner, new(ViewerVerb.ListFull, Body: "two")));
+        await Assert.That(untagged.Unchanged).IsFalse();
+        await Assert.That(untagged.Tag).IsNull();
+    }
+
     /// <summary>
     /// A pending file with no tray running. The paths ride key and body rather than an encoded
     /// payload, because that is all a tracked move or delete is.
@@ -592,6 +635,10 @@ public void TrackDelete(string file) =>
 
         public ViewerResponse Listing(bool withPatches) => ViewerResponse.Listing([]);
 
+        public string? Tag { get; set; }
+
+        public string? ListingTag() => Tag;
+
         public bool Has(string key) => true;
 
         public (bool ok, string? message, bool written) Accept(string key, string? origin)

src/DiffEngine/Protocol/IQueueOwner.cs

@@ -42,6 +42,14 @@ interface IQueueOwner
     /// </summary>
     ViewerResponse Listing(bool withPatches);
 
+    /// <summary>
+    /// Something that changes whenever the full listing would, and is cheap to take: the listing
+    /// is every patch serialized, and an attached viewer asks for it five times a second. Unique
+    /// to this owner, so a tag from an owner that has since restarted can never match. Null to
+    /// always answer in full.
+    /// </summary>
+    string? ListingTag();
+
     bool Has(string key);
 
     /// <summary>

src/DiffEngine/Protocol/ViewerMessageHandler.cs

@@ -26,7 +26,7 @@ public static ViewerResponse Handle(IQueueOwner owner, ViewerMessage message)
             case ViewerVerb.List:
                 return owner.Listing(false);
             case ViewerVerb.ListFull:
-                return owner.Listing(true);
+                return ListFull(owner, message.Body);
             case ViewerVerb.Accept:
             case ViewerVerb.Discard:
                 return Act(owner, message.Key, message.Body, message.Verb);
@@ -134,6 +134,28 @@ static ViewerResponse Delete(IQueueOwner owner, string? file)
         return ViewerResponse.Success();
     }
 
+    /// <summary>
+    /// The body is the tag of the listing the reader already holds, if any. A reader that predates
+    /// tags sends none and gets the listing in full, as ever.
+    /// </summary>
+    static ViewerResponse ListFull(IQueueOwner owner, string? since)
+    {
+        // Taken before the listing is built and never after. A change landing in between then
+        // costs one more full listing next time, where the other order sent a listing older than
+        // the tag it went under, and the reader would have kept it until something else changed.
+        var tag = owner.ListingTag();
+        if (tag is not null &&
+            tag == since)
+        {
+            return ViewerResponse.UnchangedSince(tag);
+        }
+
+        return owner.Listing(true) with
+        {
+            Tag = tag
+        };
+    }
+
     static ViewerResponse Act(IQueueOwner owner, string? key, string? body, ViewerVerb verb)
     {
         if (key is null)

src/DiffEngine/Protocol/ViewerResponse.cs

@@ -79,6 +79,28 @@ record ViewerResponse(
     /// </summary>
     public bool? Written { get; init; }
 
+    /// <summary>
+    /// On a full listing: what the owner's queue looked like when it was taken, for the reader to
+    /// send back on its next <see cref="ViewerVerb.ListFull"/>. Opaque, and only ever compared for
+    /// equality by the owner that made it. Null from an owner that predates it.
+    /// </summary>
+    public string? Tag { get; init; }
+
+    /// <summary>
+    /// The answer to a full listing whose tag still stands: nothing has changed, so nothing is
+    /// sent, and the reader keeps what it has. An attached viewer asks five times a second, and a
+    /// full listing is every patch base64'd twice by the owner, inside its gate, and parsed again
+    /// by the reader.
+    /// </summary>
+    public bool Unchanged { get; init; }
+
+    public static ViewerResponse UnchangedSince(string tag) =>
+        new(true, null, [])
+        {
+            Tag = tag,
+            Unchanged = true
+        };
+
     public static ViewerResponse Success(string? message = null) =>
         new(true, message, []);
 
@@ -123,6 +145,12 @@ public string Build()
             builder.Append($"written: {(written ? "true" : "false")}\n");
         }
 
+        ViewerPayload.Append(builder, "tag", Tag);
+        if (Unchanged)
+        {
+            builder.Append("unchanged: true\n");
+        }
+
         foreach (var item in Items)
         {
             var status = item.Status is null ? "" : ViewerPayload.Encode(item.Status);
@@ -172,6 +200,8 @@ public static bool TryParse(string text, [NotNullWhen(true)] out ViewerResponse?
         string? windowKey = null;
         AcceptProgress? progress = null;
         bool? written = null;
+        string? tag = null;
+        var unchanged = false;
         var items = new List<ViewerResponseItem>();
         var moves = new List<ViewerResponseMove>();
         var deletes = new List<ViewerResponseDelete>();
@@ -208,6 +238,16 @@ public static bool TryParse(string text, [NotNullWhen(true)] out ViewerResponse?
                 case "written":
                     written = value == "true";
                     continue;
+                case "tag":
+                    if (!ViewerPayload.TryDecode(value, out tag))
+                    {
+                        return false;
+                    }
+
+                    continue;
+                case "unchanged":
+                    unchanged = value == "true";
+                    continue;
                 case "message":
                     if (!ViewerPayload.TryDecode(value, out message))
                     {
@@ -289,7 +329,9 @@ public static bool TryParse(string text, [NotNullWhen(true)] out ViewerResponse?
             Moves = moves,
             Deletes = deletes,
             Progress = progress,
-            Written = written
+            Written = written,
+            Tag = tag,
+            Unchanged = unchanged
         };
         return true;
     }

src/DiffEngineTray.Tests/TrayViewerSyncTest.cs

@@ -281,6 +281,33 @@ public async Task AViewerGroupAcceptCarriesOutItsDeletesOnceTheTrayWroteTheSnaps
         await Assert.That(await File.ReadAllTextAsync(move.Target)).IsEqualTo("received");
     }
 
+    /// <summary>
+    /// The tray answers an unchanged listing without it, but its tracked files change on their own
+    /// scan rather than through the queue, and a focus it has stashed only reaches a window on a
+    /// listing. Neither may be taken for unchanged.
+    /// </summary>
+    [Test]
+    public async Task ATrackedFileOrAStashedFocusIsNeverAnsweredUnchanged()
+    {
+        await using var pair = new TrayOwned();
+        var snapshot = pair.Queue(sample, 1);
+        var tag = pair.Send(new(ViewerVerb.ListFull)).Tag;
+        await Assert.That(pair.Send(new(ViewerVerb.ListFull, Body: tag)).Unchanged).IsTrue();
+
+        pair.AddDelete();
+        var withDelete = pair.Send(new(ViewerVerb.ListFull, Body: tag));
+        await Assert.That(withDelete.Unchanged).IsFalse();
+        await Assert.That(withDelete.Deletes).HasSingleItem();
+
+        pair.Host.Focus(snapshot);
+        var focused = pair.Send(new(ViewerVerb.ListFull, Body: withDelete.Tag));
+        await Assert.That(focused.Unchanged).IsFalse();
+        await Assert.That(focused.Window).IsEqualTo(WindowCommand.Focus);
+
+        // Taken by that listing, so the next is unchanged again
+        await Assert.That(pair.Send(new(ViewerVerb.ListFull, Body: focused.Tag)).Unchanged).IsTrue();
+    }
+
     [Test]
     public async Task ViewerDiscardOfOneSnapshotReachesTheTray()
     {

src/DiffEngineTray/OwnedInlineHost.cs

@@ -41,6 +41,16 @@ sealed class OwnedInlineHost :
     /// </summary>
     AcceptProgress? progress;
 
+    /// <summary>
+    /// What <see cref="IQueueOwner.ListingTag"/> is made of, under <see cref="gate"/>. The queue
+    /// is immutable and replaced on every change, so a new reference is a new generation; asks
+    /// counts window commands stashed, so a listing carrying one is never answered unchanged.
+    /// </summary>
+    readonly string instance = Guid.NewGuid().ToString("N");
+    InlineQueue? taggedQueue;
+    long generation;
+    long asks;
+
     /// <summary>
     /// One accept-all at a time. The menu, a hot key and a displaying viewer can each ask for one,
     /// and two sweeping the same queue at once would apply every snapshot twice and report two
@@ -284,6 +294,40 @@ ViewerResponse IQueueOwner.Listing(bool withPatches)
         }
     }
 
+    string IQueueOwner.ListingTag()
+    {
+        // The tracked files by what the listing would carry of them rather than by a count, since
+        // the tracker changes them on its own scan as well as through here. A handful of paths,
+        // where the listing it saves is every patch.
+        var files = TrackedFiles is { } tracked ? Fingerprint(tracked) : "";
+        lock (gate)
+        {
+            if (!ReferenceEquals(queue, taggedQueue))
+            {
+                taggedQueue = queue;
+                generation++;
+            }
+
+            return $"{instance}.{generation}.{asks}.{progress?.Build()}.{files}";
+        }
+    }
+
+    static string Fingerprint(ITrackedFiles tracked)
+    {
+        var builder = new StringBuilder();
+        foreach (var move in tracked.Moves())
+        {
+            builder.Append(move).Append('\n');
+        }
+
+        foreach (var delete in tracked.Deletes())
+        {
+            builder.Append(delete).Append('\n');
+        }
+
+        return Convert.ToHexString(System.Security.Cryptography.SHA256.HashData(Encoding.UTF8.GetBytes(builder.ToString())));
+    }
+
     bool IQueueOwner.Has(string key)
     {
         if (TrackedKeys.IsTracked(key))
@@ -650,6 +694,7 @@ void Ask(WindowCommand command, string? key)
         {
             window = command;
             windowKey = key;
+            asks++;
         }
     }
 

src/DiffEngineViewer.Tests/AttachedViewerTests.cs

@@ -36,6 +36,70 @@ await Assert.That(queue.Select(_ => _.Name))
         await Assert.That(queue[0].TotalRows).IsGreaterThan(0);
     }
 
+    /// <summary>
+    /// Asked with the tag of the listing it gave last, an owner whose queue has not moved answers
+    /// that and nothing else, rather than every patch again. Any change makes it answer in full.
+    /// </summary>
+    [Test]
+    public async Task AnUnchangedQueueIsNotSentAgain()
+    {
+        using var owner = new ServerFixture();
+        owner.Send(Inline(Fixtures.Patch()));
+
+        var full = owner.Send(new(ViewerVerb.ListFull));
+        await Assert.That(full.Tag).IsNotNull();
+        await Assert.That(full.Items).HasSingleItem();
+
+        var same = owner.Send(new(ViewerVerb.ListFull, Body: full.Tag));
+        await Assert.That(same.Unchanged).IsTrue();
+        await Assert.That(same.Items).IsEmpty();
+
+        owner.Send(Inline(Fixtures.Patch("OtherTests.cs", 7, null, "new")));
+        var changed = owner.Send(new(ViewerVerb.ListFull, Body: full.Tag));
+        await Assert.That(changed.Unchanged).IsFalse();
+        await Assert.That(changed.Items.Count).IsEqualTo(2);
+    }
+
+    /// <summary>
+    /// What an unchanged answer stands for is the listing held from before it, so the window keeps
+    /// showing it, and still follows the owner once something does change.
+    /// </summary>
+    [Test]
+    public async Task AnAttachedViewerFollowsAChangeAfterAnUnchangedListing()
+    {
+        using var owner = new ServerFixture();
+        owner.Send(Inline(Fixtures.Patch()));
+        var (host, link) = Attach(owner);
+        link.Pump();
+        var shown = host.State;
+
+        link.Pump();
+        await Assert.That(host.State).IsSameReferenceAs(shown);
+
+        owner.Send(Inline(Fixtures.Patch("OtherTests.cs", 7, null, "new")));
+        link.Pump();
+        await Assert.That(host.State.Queue.Select(_ => _.Name))
+            .IsEquivalentTo(["SampleTests.cs:42", "OtherTests.cs:7"]);
+    }
+
+    /// <summary>
+    /// A send that changes nothing still says so, on a listing that was answered unchanged.
+    /// </summary>
+    [Test]
+    public async Task ARefusalArrivesOnAnUnchangedListing()
+    {
+        using var owner = new ServerFixture();
+        owner.Send(Inline(Fixtures.Patch()));
+        var (host, link) = Attach(owner);
+        link.Pump();
+
+        link.Post(ViewerVerb.Discard, "nothing|1");
+        link.Pump();
+
+        await Assert.That(host.State.Message).IsEqualTo("No pending snapshot for nothing|1");
+        await Assert.That(host.State.Queue).HasSingleItem();
+    }
+
     [Test]
     public async Task AFailedEntryKeepsItsStatus()
     {

src/DiffEngineViewer.Tests/IpcTests.AcceptAnUnknownKey.verified.txt

@@ -1,4 +1,5 @@
 {
   Ok: false,
-  Message: No pending snapshot for missing|1
+  Message: No pending snapshot for missing|1,
+  Unchanged: false
 }

src/DiffEngineViewer.Tests/IpcTests.List.verified.txt

@@ -9,5 +9,6 @@
       Key: othertests.cs|7,
       Name: othertests.cs:7
     }
-  ]
+  ],
+  Unchanged: false
 }