summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/replica.zig108
1 files changed, 108 insertions, 0 deletions
diff --git a/src/replica.zig b/src/replica.zig
index a18391d4..92ee7b37 100644
--- a/src/replica.zig
+++ b/src/replica.zig
@@ -571,6 +571,9 @@ pub const Replica = struct {
if (r.copy.held) {
r.copy.restore();
rollback.Epoch.select(null);
+ // The copy's terminal rows are of a grid the deltas since moved
+ // on from: a rollback never brings a terminal's past back.
+ r.core().shell_rows.stale = true;
}
r.applied = 0;
for (r.since.items) |u| if (tape.replayUnit(&r.t, u)) |why| return r.fail(why);
@@ -703,6 +706,8 @@ pub const Replica = struct {
r.stats.apply_ns.append(r.gpa, nowNs() - t0) catch {};
sc.refused = false;
terminal.takeMarks(state, applied.extra);
+ // Its rows as the core keeps them read are another grid's.
+ c.shell_rows.markStale(pane);
var seq: [4]u8 = undefined;
std.mem.writeInt(u32, &seq, applied.seq, .little);
return r.screenMessage(m.pane, m.serial, kind_ack, &seq);
@@ -710,6 +715,7 @@ pub const Replica = struct {
kind_rows => {
sc.asked = null;
sc.rep.applyRows(r.coreGpa(), &state.vt, m.payload) catch r.fail("a terminal's rows did not apply");
+ c.shell_rows.markStale(pane);
return null;
},
else => return null,
@@ -855,3 +861,105 @@ test "another client's input first: a replica rolls back, replays it and applies
try std.testing.expect(r1.stats.foreign >= 1);
try std.testing.expectEqual(@as(u32, 4), r2.stats.fast);
}
+
+fn screensTo(a: *Authority, screens: *Screens, peer: u16, r: *Replica) !void {
+ const gpa = std.testing.allocator;
+ var msgs: std.ArrayListUnmanaged([]u8) = .empty;
+ defer {
+ for (msgs.items) |m| gpa.free(m);
+ msgs.deinit(gpa);
+ }
+ try screens.flush(a.core, peer, &msgs);
+ for (msgs.items) |m| if (r.screen(m)) |reply| {
+ _ = try screens.take(a.core, peer, reply);
+ };
+}
+
+test "a delta applied under a speculation outlives its rollback: the terminal stays the authority's newest" {
+ if (comptime !terminal.enabled) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const a = try Authority.init(gpa, .{ .cols = 80, .rows = 24, .boot = .tty }, TestHost.host(), true);
+ defer a.deinit();
+ var screens: Screens = .init(gpa);
+ defer screens.deinit(a.core);
+ const peer = try screens.addPeer();
+ const r = try Replica.init(gpa, 1, try a.unit(0, 0), true);
+ defer r.deinit();
+ const shell: u8 = for (a.core.panes, 0..) |slot, id| {
+ if (slot) |pane| if (pane.isTerminal()) break @intCast(id);
+ } else return error.NoShell;
+ // Typing goes to the text pane under the shell (the host's write of
+ // `active`, taped).
+ a.core.active = for (a.core.panes, 0..) |slot, id| {
+ if (slot) |pane| if (pane.file != null) break id;
+ } else return error.NoTextPane;
+ r.confirm(try a.local(.{ .focus = true }));
+ try screensTo(a, &screens, peer, r);
+ var sent: std.ArrayListUnmanaged([]u8) = .empty;
+ defer {
+ for (sent.items) |m| gpa.free(m);
+ sent.deinit(gpa);
+ }
+ // Typed into the file, at once: a copy is held.
+ try key(r, 'o', &sent);
+ try std.testing.expect(r.copy.held);
+ var line: [64]u8 = undefined;
+ for (0..3) |round| {
+ // The shell prints: its unit rolls the replica back and applies the
+ // key again; then its delta lands, under the new copy.
+ for (0..40) |i| a.output(.{ .output = .{ .pane = shell, .bytes = try std.fmt.bufPrint(&line, "round {d} line {d}\r\n", .{ round, i }) } });
+ r.confirm((try a.pending()).?);
+ r.settle();
+ try std.testing.expect(r.copy.held);
+ try screensTo(a, &screens, peer, r);
+ // The rows the core keeps, read once under the copy.
+ _ = try terminal.shellRows(r.core(), r.core().panes[shell].?);
+ }
+ for (sent.items) |m| {
+ r.confirm(try a.take(m));
+ r.settle();
+ gpa.free(m);
+ }
+ sent.clearRetainingCapacity();
+ try screensTo(a, &screens, peer, r);
+ // Drawn (its rows read, between steps), then typed into: the copy keeps
+ // those rows. The shell prints, its delta lands under the copy, and then
+ // another's unit puts the copy back: the rows it kept are of an older
+ // grid and must not be read.
+ r.confirm(try a.local(.{ .focus = false }));
+ _ = try terminal.shellRows(r.core(), r.core().panes[shell].?);
+ try key(r, 'x', &sent);
+ for (0..40) |i| a.output(.{ .output = .{ .pane = shell, .bytes = try std.fmt.bufPrint(&line, "last line {d}\r\n", .{i}) } });
+ r.confirm((try a.pending()).?);
+ r.settle();
+ try screensTo(a, &screens, peer, r);
+ r.confirm(try a.local(.{ .focus = true }));
+ r.settle();
+ const n = a.core.panes[shell].?.rows;
+ const back = try terminal.shellRows(r.core(), r.core().panes[shell].?);
+ const now = try terminal.shellRows(a.core, a.core.panes[shell].?);
+ for (now[now.len - n ..], back[back.len - n ..]) |x, y| try std.testing.expectEqualStrings(x, y);
+ for (sent.items) |m| {
+ r.confirm(try a.take(m));
+ r.settle();
+ }
+ try screensTo(a, &screens, peer, r);
+ if (r.diverged) |why| std.debug.print("diverged: {s}\n", .{why});
+ try std.testing.expect(r.diverged == null and r.quiet());
+ try std.testing.expectEqual(digestOf(a), r.digest());
+ var dump_a: std.Io.Writer.Allocating = .init(gpa);
+ defer dump_a.deinit();
+ var dump_r: std.Io.Writer.Allocating = .init(gpa);
+ defer dump_r.deinit();
+ try screen_state.dumpScreen(&a.core.panes[shell].?.terminal.?.vt, &dump_a.writer);
+ try screen_state.dumpScreen(&r.core().panes[shell].?.terminal.?.vt, &dump_r.writer);
+ try std.testing.expectEqualStrings(dump_a.written(), dump_r.written());
+ const rows_a = try terminal.shellRows(a.core, a.core.panes[shell].?);
+ const rows_r = try terminal.shellRows(r.core(), r.core().panes[shell].?);
+ // As many rows (the history is the authority's to the row), the screen's
+ // the same; above it, rows scrolled past more than a screen at once are
+ // holes until fetched.
+ try std.testing.expectEqual(rows_a.len, rows_r.len);
+ const shown = a.core.panes[shell].?.rows;
+ for (rows_a[rows_a.len - shown ..], rows_r[rows_r.len - shown ..]) |x, y| try std.testing.expectEqualStrings(x, y);
+}