summaryrefslogtreecommitdiff
path: root/test/process/root_ctl.zig
blob: 87c9e77708608947bab301463dc46e82b4e306c3 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
//! docs/typ/reference.typ, The root ctl <root-ctl>: Dump and Restore in a
//! real session, detached and in a pty.
const std = @import("std");
const process = @import("../process.zig");
const Conn = process.Conn;
const has = process.has;
const check = process.check;

pub const cases = .{
    .{ "root-ctl: Restore asks once about unsaved text, is answered before it cuts every connection, and the dump's panes come back under their serials", restore },
};

/// A connection to `path`, waiting up to 5 s for it to answer.
fn redial(gpa: std.mem.Allocator, path: []const u8) !*Conn {
    const deadline = process.nowMs() + 5_000;
    while (true) {
        if (Conn.dial(gpa, path)) |c| return c else |err| if (process.nowMs() > deadline) return err;
        process.nap(20);
    }
}

fn restore(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
    for ([_]bool{ false, true }) |tty| {
        var arena = std.heap.ArenaAllocator.init(gpa);
        defer arena.deinit();
        const a = arena.allocator();
        const name = if (tty) "restore tty space" else "restore detached space";
        var d = try process.Detached.start(gpa, exe, if (tty) "restore-root" else name, .{});
        defer d.deinit();
        var term: ?process.Child = null;
        defer if (term) |*t| t.deinit();
        if (tty) term = try d.startTty(exe, name, &.{});
        const address = d.abs(try std.fmt.allocPrint(a, "pardes-9p-{s}.sock", .{name}));
        const old = try Conn.dial(gpa, address);
        defer old.deinit(gpa);
        try old.replace("/pane/1/body", "dumped state\n");
        const control = try old.newPane(a);
        try old.execRefused(control, try std.fmt.allocPrint(a, "Restore {s}\n", .{d.abs("missing dump.zon")}), "no such file");
        try std.testing.expectEqualStrings("dumped state\n", try old.read(a, "/pane/1/body"));
        try old.exec(control, try std.fmt.allocPrint(a, "Mount own {s}\n", .{address}));
        try old.exec(control, "Dump\n");
        const saved_rel = try std.fmt.allocPrint(a, "{s}.dump.zon", .{name});
        const saved = d.abs(saved_rel);
        const deadline = process.nowMs() + 5_000;
        while (!d.exists(saved_rel)) {
            if (process.nowMs() > deadline) return error.NoDump;
            process.nap(5);
        }
        const held_body = try old.hold("/pane/1/body", 0);
        const held_screen = try old.hold("/screen", 0);
        const old_ids = try old.serials(a);
        try std.testing.expectEqualStrings("dumped state\n", try old.readFid(held_body, 0, 65536));
        try std.testing.expectEqualStrings("{", try old.readFid(held_screen, 0, 1));
        try old.replace("/pane/1/body", "changed after dump\n");
        // Unsaved text is asked about once, as Exit asks; the second Restore
        // goes ahead, and is answered before the hang-up.
        const line = try std.fmt.allocPrint(a, "Restore {s}\n", .{saved});
        if (old.exec(control, line)) |_| {} else |err| {
            if (err != error.Refused) return err;
            try check(has(old.said, "Modified"), "Restore refused: {s}", .{old.said});
        }
        try std.testing.expectEqualStrings("changed after dump\n", try old.read(a, "/pane/1/body"));
        // Answered before the hang-up: the write's reply comes; the clunk
        // after it may meet the connection already cut.
        const restore_fid = try old.hold(try std.fmt.allocPrint(a, "/pane/{d}/exec", .{control}), 1);
        _ = try old.writeFid(restore_fid, 0, line);
        old.clunk(restore_fid);
        // Refused while the connections are cut, or cut already.
        if (old.readFid(held_body, 0, 65536)) |_| return error.OldFidUsable else |_| {}
        const restored = try redial(gpa, address);
        defer restored.deinit(gpa);
        // The new log names its panes, then where they came from.
        const log = try restored.read(a, "/log");
        try check(has(log, try std.fmt.allocPrint(a, "\nrestore {s}\n", .{saved})), "no restore logged: {s}", .{log});
        // Its panes are the dump's, their serials too.
        const ids = try restored.serials(a);
        try check(ids.len == 2 and std.mem.eql(u32, ids, old_ids), "restored {any}, dumped {any}", .{ ids, old_ids });
        try std.testing.expectEqualStrings("dumped state\n", try restored.pane(a, ids[0], "body"));
        try check((try restored.pane(a, ids[1], "body")).len == 0, "commands ran through exec, not the body", .{});
        var screen: process.Files = .init(gpa, address);
        defer screen.deinit();
        const width = try std.unicode.utf8CountCodepoints(std.mem.sliceTo(try screen.screen(), '\n'));
        try std.testing.expectEqual(@as(usize, if (tty) 80 else 160), width); // a detached one is 160x50
        const opened = try restored.look(a, try std.fmt.allocPrint(a, "/n/own/os{s}", .{d.abs(try std.fmt.allocPrint(a, "{s}.txt", .{name}))}), ids[1]);
        try std.testing.expectEqualStrings("initial\n", try restored.pane(a, opened, "body"));
    }
}