1 files changed, 28 insertions, 9 deletions

diff --git a/src/ninep/events.zig b/src/ninep/events.zig
index 570cae78..fe7af77e 100644
--- a/src/ninep/events.zig
+++ b/src/ninep/events.zig
@@ -171,11 +171,11 @@ pub fn noteMessage(p: *Pardes, serial: u32, said: []const u8) void {
     pushCounting(p, (if (serial == 0)
         std.fmt.bufPrint(&buf, "msg - {s}{s}\n", .{ kept, cut })
     else
-        std.fmt.bufPrint(&buf, "msg {d} {s}{s}\n", .{ serial, kept, cut })) catch return);
+        std.fmt.bufPrint(&buf, "msg {d} {s}{s}\n", .{ serial, kept, cut })) catch return, said);
 }
 
-/// Records `err <serial|-> <file>: <why>` for a write or truncation that was
-/// refused or failed: through a mount a shell sees only the errno the
+/// Records `err <serial|-> <file>: <why>` for a write that was refused or
+/// failed: through a mount a shell sees only the errno the
 /// kernel mapped the reply to (`Invalid argument`), and here is the reason.
 /// The log is the one place for it, as acme's `errors` file takes text and
 /// answers nothing: a per-pane readable error file would be a second.
@@ -186,7 +186,7 @@ pub fn noteMessage(p: *Pardes, serial: u32, said: []const u8) void {
 pub fn noteErrCounted(p: *Pardes, text: []const u8) void {
     bootFirst(p);
     var buf: [pardes.memory.limits.host_path_cap + 16]u8 = undefined;
-    pushCounting(p, std.fmt.bufPrint(&buf, "err {s}\n", .{text}) catch return);
+    pushCounting(p, std.fmt.bufPrint(&buf, "err {s}\n", .{text}) catch return, text);
 }
 
 pub fn notePath(p: *Pardes, what: []const u8, path: []const u8) void {
@@ -239,7 +239,7 @@ pub fn noteError(p: *Pardes, req: Req, reply: Reply) void {
     for (record[0 .. record.len - 1]) |*c| if (c.* < ' ') {
         c.* = ' ';
     };
-    pushCounting(p, record);
+    pushCounting(p, record, reason);
 }
 
 /// Drops the newest record when it is a msg saying `text` (of any pane)
@@ -256,7 +256,11 @@ pub fn dropMessage(p: *Pardes, text: []const u8) void {
 /// counts that one instead: `<record> (x2)`, the count being every time it
 /// was said. One a follower has already read is not rewritten: the repeat
 /// is a new line carrying the running count, `(x3)`.
-fn pushCounting(p: *Pardes, raw: []u8) void {
+/// `full` is the text before any cut: two records that agree only in what
+/// was cut to fit are no repeat (`fs.log_full_hash`).
+fn pushCounting(p: *Pardes, raw: []u8, full: []const u8) void {
+    const full_hash = std.hash.Wyhash.hash(0, full);
+    defer p.fs.log_full_hash = full_hash;
     // A client retrying a write that fails the same way would fill the ring
     // with one line, so a repeat of the newest record is that record counted,
     // `(x3)`, as +Messages counts its repeats; unless a follower has read it
@@ -272,7 +276,7 @@ fn pushCounting(p: *Pardes, raw: []u8) void {
             said = said[0..x];
         } else |_| {}
     };
-    if (!std.mem.eql(u8, said, record[0 .. record.len - 1])) return pushLog(p, record);
+    if (!std.mem.eql(u8, said, record[0 .. record.len - 1]) or p.fs.log_full_hash != full_hash) return pushLog(p, record);
     var counted: [pardes.Messages.LoggedMessage.cap + 64]u8 = undefined;
     const again = std.fmt.bufPrint(&counted, "{s} (x{d})\n", .{ said, times +| 1 }) catch return;
     if (!followerRead(p, last.seq)) p.fs.log.buf.shrinkRetainingCapacity(last.at);
@@ -373,6 +377,8 @@ fn shownAs(text: []const u8, out: []u8, escape_newline: bool) []u8 {
 }
 
 fn pushLog(p: *Pardes, raw: []u8) void {
+    // A record not counted: the next one is no repeat of a counted one.
+    p.fs.log_full_hash = 0;
     var clean: [4 * 4096 + 256]u8 = undefined;
     const record = sanitize(raw, &clean);
     // One record larger than the ring would push every other out and then
@@ -1283,7 +1289,7 @@ test "a record is one line of UTF-8: DEL and C1 are spaces, bytes not UTF-8 are
     try testing.expectEqualStrings("msg - caf\xc3\xa9\n", sanitize("msg - caf\xc3\xa9\n", &out));
 }
 
-test "a long err record is cut between words, with an ellipsis" {
+test "a long err record keeps its end, its middle given up to an ellipsis" {
     const p = try withFile(testing.allocator, "x\n");
     defer p.deinit();
     _ = wr(p, @intFromEnum(tree.TopFile.ctl), "Bogus " ++ "abcdefgh " ** 40 ++ "\n");
@@ -1292,6 +1298,19 @@ test "a long err record is cut between words, with an ellipsis" {
     const text = call(p, .{ .tag = 2, .op = .read, .node = log, .handle = h, .size = 1 << 16 }).bytes;
     const at = std.mem.lastIndexOf(u8, text, "err - ctl: ").?;
     const record = text[at .. std.mem.indexOfScalarPos(u8, text, at, '\n').? + 1];
-    try testing.expect(std.mem.endsWith(u8, record, "abcdefgh…\n"));
+    try testing.expect(std.mem.indexOf(u8, record, "…") != null);
+    try testing.expect(std.mem.startsWith(u8, record, "err - ctl: "));
+    try testing.expect(std.mem.endsWith(u8, record, "abcdefgh\"\n") or std.mem.endsWith(u8, record, "abcdefgh \"\n"));
     _ = call(p, .{ .tag = 3, .op = .release, .node = log, .handle = h });
 }
+
+test "two failures that agree only in what their records cut are two records, not one counted" {
+    const p = try th.withFile(testing.allocator, "x\n");
+    defer p.deinit();
+    const long = "why " ** 80;
+    p.setMessage(0, long ++ "first");
+    p.setMessage(0, long ++ "second");
+    try testing.expect(!th.logHas(p, "(x2)"));
+    p.setMessage(0, long ++ "second");
+    try testing.expect(th.logHas(p, "(x2)"));
+}