const std = @import("std");
const repeat = @import("zit").repeat;
const container = @import("zit").container;
const sync = @import("zit").sync;
const zit = @import("zit");
const net = std.Io.net;
const support = @import("support.zig");
const XferHead = support.XferHead;
const addManaged = support.addManaged;
const artifactNameByContent = support.artifactNameByContent;
const checkinHash = support.checkinHash;
const collectArtifactDigests = support.collectArtifactDigests;
const commitHashDup = support.commitHashDup;
const dialServe = support.dialServe;
const doomed_body = support.doomed_body;
const erasureOk = support.erasureOk;
const erasureOrigin = support.erasureOrigin;
const erasure_seed_hex = support.erasure_seed_hex;
const expectContains = support.expectContains;
const expectExit = support.expectExit;
const expectExitDiag = support.expectExitDiag;
const expectNonzeroExit = support.expectNonzeroExit;
const expectSameDigestSet = support.expectSameDigestSet;
const fileExists = support.fileExists;
const freeDigests = support.freeDigests;
const freeResult = support.freeResult;
const freshLoopbackPort = support.freshLoopbackPort;
const initRepo = support.initRepo;
const kept_body = support.kept_body;
const postXferCards = support.postXferCards;
const postXferCardsHead = support.postXferCardsHead;
const postXferCardsHeaders = support.postXferCardsHeaders;
const readAutoRetune = support.readAutoRetune;
const readProjectCode = support.readProjectCode;
const readSubmanifestSettings = support.readSubmanifestSettings;
const runCommitEnv = support.runCommitEnv;
const runZit = support.runZit;
const shunFixture = support.shunFixture;
const spawnServe = support.spawnServe;
const spawnServeFlag = support.spawnServeFlag;
const spawnServeFlags = support.spawnServeFlags;
const spawnServeFronted = support.spawnServeFronted;
const storeHoldsArtifact = support.storeHoldsArtifact;
const tipHashOf = support.tipHashOf;
const waitForListen = support.waitForListen;
const writeFile = support.writeFile;
test "cli serve §9.3 r31: an unauthorized pushed config card is refused and changes nothing" {
const gpa = std.testing.allocator;
const io = std.testing.io;
// Repo A: enabled at k=3, auto-retune off — a settled configuration a
// stranger is about to try to rewrite.
var tmp_a = std.testing.tmpDir(.{});
defer tmp_a.cleanup();
try initRepo(gpa, io, tmp_a.dir);
try writeFile(io, tmp_a.dir, "hello.txt", "served repository\n");
try addManaged(gpa, io, tmp_a.dir, &.{"hello.txt"});
var commit = try runCommitEnv(gpa, io, tmp_a.dir, .{ .user = "u" }, &.{ "commit", "-m", "seed" });
defer freeResult(gpa, &commit);
try expectExit(commit.term, 0);
{
var en = try runZit(gpa, io, tmp_a.dir, &.{ "submanifest", "enable", "--k", "3" });
defer freeResult(gpa, &en);
try expectExitDiag(en.term, 0, en);
}
const port = try freshLoopbackPort(io);
var server = try spawnServe(gpa, io, tmp_a.dir, port);
defer server.kill(io);
try waitForListen(io, port);
// §9.3 r30 — a well-formed scalar config push, from nobody: `zit serve`
// holds no credential, so no requester can ever reach Admin.
var cards_buf: [sync.submanifest_config_cards_max]u8 = undefined;
const cards = try sync.writeSubmanifestConfigCards(false, 11, true, "", &cards_buf);
const request = try std.fmt.allocPrint(gpa, "pragma client-version 20000\n{s}", .{cards});
defer gpa.free(request);
const reply = try postXferCards(gpa, io, port, request);
defer gpa.free(reply);
// §9.3 r31 L2023-2026 — the exact required text (§11.1 r2 fossilizes its
// spaces on the wire), and nothing else in the reply: the rejection resets
// the partial output.
try std.testing.expectEqualStrings("error not\\sauthorized\\sto\\spush\\sconfiguration\n", reply);
// THE PROOF: A's stored configuration is byte-for-byte what it was. A
// server that applied the push would show k=11 and auto-retune on here.
const a = try readSubmanifestSettings(gpa, io, tmp_a.dir);
try std.testing.expect(a.enabled);
try std.testing.expectEqual(@as(u8, 3), a.k);
try std.testing.expect(!try readAutoRetune(gpa, io, tmp_a.dir));
}
test "cli serve §9.3: a peer that never asks for configuration still clones unchanged" {
const gpa = std.testing.allocator;
const io = std.testing.io;
// The interop case for a peer predating this feature: a request that
// carries NO reqconfig must draw no config card and no error — the "group
// mask zero" no-op extended to a peer that simply does not ask. Simulated
// at the wire, because every zit clone now does ask.
var tmp_a = std.testing.tmpDir(.{});
defer tmp_a.cleanup();
try initRepo(gpa, io, tmp_a.dir);
try writeFile(io, tmp_a.dir, "hello.txt", "served repository\n");
try addManaged(gpa, io, tmp_a.dir, &.{"hello.txt"});
var commit = try runCommitEnv(gpa, io, tmp_a.dir, .{ .user = "u" }, &.{ "commit", "-m", "seed" });
defer freeResult(gpa, &commit);
try expectExit(commit.term, 0);
{
var en = try runZit(gpa, io, tmp_a.dir, &.{ "submanifest", "enable", "--k", "3" });
defer freeResult(gpa, &en);
try expectExitDiag(en.term, 0, en);
}
const a_digests = try collectArtifactDigests(gpa, io, tmp_a.dir);
defer freeDigests(gpa, a_digests);
const port = try freshLoopbackPort(io);
var server = try spawnServe(gpa, io, tmp_a.dir, port);
defer server.kill(io);
try waitForListen(io, port);
// §8.5 — the pull names the served project, as any peer of it would.
const pcode = try readProjectCode(gpa, io, tmp_a.dir);
defer gpa.free(pcode);
const pull = try std.fmt.allocPrint(gpa, "pragma client-version 20000\npull s {s}\n", .{pcode});
defer gpa.free(pull);
const silent = try postXferCards(gpa, io, port, pull);
defer gpa.free(silent);
try std.testing.expect(std.mem.indexOf(u8, silent, "config") == null);
try std.testing.expect(std.mem.indexOf(u8, silent, "error") == null);
// §9.3 r28 — `/shun` IS modelled now, but this repository shuns nothing, so
// an empty table answers with no cards and no error. Same silent shape a
// group with no rows always had; the populated case is its own test below.
const table = try postXferCards(gpa, io, port, "pragma client-version 20000\nreqconfig /shun\n");
defer gpa.free(table);
try std.testing.expect(std.mem.indexOf(u8, table, "config /") == null);
try std.testing.expect(std.mem.indexOf(u8, table, "error") == null);
const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
defer gpa.free(url);
try expectCloneConverges(gpa, io, &tmp_a, url, a_digests);
}
test "cli serve --adopt-project: an empty fronted store takes the first push's project (sync §8.5)" {
const gpa = std.testing.allocator;
const io = std.testing.io;
// A, an existing project with a check-in.
var tmp_a = std.testing.tmpDir(.{});
defer tmp_a.cleanup();
try initRepo(gpa, io, tmp_a.dir);
try writeFile(io, tmp_a.dir, "a.txt", "the project being moved\n");
try addManaged(gpa, io, tmp_a.dir, &.{"a.txt"});
var commit_a = try runCommitEnv(gpa, io, tmp_a.dir, .{ .user = "u" }, &.{ "commit", "-m", "a" });
defer freeResult(gpa, &commit_a);
try expectExit(commit_a.term, 0);
const a_code = try readProjectCode(gpa, io, tmp_a.dir);
defer gpa.free(a_code);
const a_digests = try collectArtifactDigests(gpa, io, tmp_a.dir);
defer freeDigests(gpa, a_digests);
// B, the empty store a forge makes; C, an unrelated project.
var tmp_b = std.testing.tmpDir(.{});
defer tmp_b.cleanup();
try initRepo(gpa, io, tmp_b.dir);
const b_init_code = try readProjectCode(gpa, io, tmp_b.dir);
defer gpa.free(b_init_code);
var tmp_c = std.testing.tmpDir(.{});
defer tmp_c.cleanup();
try initRepo(gpa, io, tmp_c.dir);
try writeFile(io, tmp_c.dir, "c.txt", "another project\n");
try addManaged(gpa, io, tmp_c.dir, &.{"c.txt"});
var commit_c = try runCommitEnv(gpa, io, tmp_c.dir, .{ .user = "u" }, &.{ "commit", "-m", "c" });
defer freeResult(gpa, &commit_c);
try expectExit(commit_c.term, 0);
const refused_push = "zit push: the peer refused: wrong project (this repository and the peer's are different projects; clone the peer to work on it)\n";
// Without the flag the same first push is refused and B is unchanged.
{
const port = try freshLoopbackPort(io);
var server = try spawnServeFlags(gpa, io, tmp_b.dir, port, &.{"--fronted"});
defer server.kill(io);
try waitForListen(io, port);
const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/xfer", .{port});
defer gpa.free(url);
var push = try runZit(gpa, io, tmp_a.dir, &.{ "push", url });
defer freeResult(gpa, &push);
try expectExitDiag(push.term, 1, push);
try std.testing.expectEqualStrings(refused_push, push.stderr);
server.kill(io);
const b_code = try readProjectCode(gpa, io, tmp_b.dir);
defer gpa.free(b_code);
try std.testing.expectEqualStrings(b_init_code, b_code);
}
const port = try freshLoopbackPort(io);
var server = try spawnServeFlags(gpa, io, tmp_b.dir, port, &.{ "--fronted", "--adopt-project" });
defer server.kill(io);
try waitForListen(io, port);
const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/xfer", .{port});
defer gpa.free(url);
// The forge flow: name the remote, then push.
{
var remote = try runZit(gpa, io, tmp_a.dir, &.{ "remote", url });
defer freeResult(gpa, &remote);
try expectExitDiag(remote.term, 0, remote);
var push = try runZit(gpa, io, tmp_a.dir, &.{"push"});
defer freeResult(gpa, &push);
try expectExitDiag(push.term, 0, push);
}
// An unrelated project is now refused, and B keeps A's code.
{
var push = try runZit(gpa, io, tmp_c.dir, &.{ "push", url });
defer freeResult(gpa, &push);
try expectExitDiag(push.term, 1, push);
try std.testing.expectEqualStrings(refused_push, push.stderr);
}
// A fresh clone of B carries A's project code and A's content.
var tmp_d = std.testing.tmpDir(.{});
defer tmp_d.cleanup();
{
var clone = try runZit(gpa, io, tmp_d.dir, &.{ "clone", "--no-open", url, "repo" });
defer freeResult(gpa, &clone);
try expectExitDiag(clone.term, 0, clone);
}
server.kill(io);
const b_code = try readProjectCode(gpa, io, tmp_b.dir);
defer gpa.free(b_code);
try std.testing.expectEqualStrings(a_code, b_code);
const b_digests = try collectArtifactDigests(gpa, io, tmp_b.dir);
defer freeDigests(gpa, b_digests);
try expectSameDigestSet(a_digests, b_digests);
var d_dir = try tmp_d.dir.openDir(io, "repo", .{});
defer d_dir.close(io);
const d_code = try readProjectCode(gpa, io, d_dir);
defer gpa.free(d_code);
try std.testing.expectEqualStrings(a_code, d_code);
const d_digests = try collectArtifactDigests(gpa, io, d_dir);
defer freeDigests(gpa, d_digests);
try expectSameDigestSet(a_digests, d_digests);
}
/// Read the first bytes of the server's HTTP reply on `stream`, returning true
/// iff they are a status line (`HTTP/…`). Run as a `Select` task so a wedged
/// server (no reply ever comes) is a cancellation point the deadline interrupts.
fn probeReadOk(io: std.Io, stream: net.Stream) bool {
var buf: [64]u8 = undefined;
var r = stream.reader(io, &buf);
const head = r.interface.take(5) catch return false;
return std.mem.eql(u8, head, "HTTP/");
}
fn probeDeadline(io: std.Io, ns: u64) void {
io.sleep(.{ .nanoseconds = @intCast(ns) }, .awake) catch {};
}
/// Bounded liveness proof: open a FRESH connection, send a well-formed HTTP
/// request head, and require a status-line reply within `window_ns`. On a
/// single-threaded server this reply cannot arrive until any prior stalled
/// connection is abandoned by the serve deadline, so `window_ns` must exceed it;
/// the race converts a persistent wedge into `error.ServerWedged` rather than an
/// unbounded hang (the bounded-waits rule: interval AND deadline). A clean
/// reply proves the accept loop was freed and the server still serves.
fn expectServesFreshRequest(io: std.Io, port: u16, window_ns: u64) !void {
const stream = dialServe(io, port) catch return error.ProbeConnectFailed;
defer stream.close(io);
{
var wbuf: [128]u8 = undefined;
var w = stream.writer(io, &wbuf);
// A GET is a well-formed request the server routes and answers (with a
// §4 classification status); the point is that a fresh connection is
// accepted and answered at all — proof the loop is not pinned.
try w.interface.writeAll("GET /xfer HTTP/1.1\r\nHost: z\r\nConnection: close\r\n\r\n");
try w.interface.flush();
}
const Outcome = union(enum) { replied: bool, expired: void };
var slots: [2]Outcome = undefined;
var race = std.Io.Select(Outcome).init(io, &slots);
try race.concurrent(.replied, probeReadOk, .{ io, stream });
race.concurrent(.expired, probeDeadline, .{ io, window_ns }) catch {
// No concurrency for the deadline task: fall back to an unbounded read
// (the server is expected to reply; this only loses the wedge ceiling).
const got = race.await() catch {
race.cancelDiscard();
return error.ProbeCanceled;
};
race.cancelDiscard();
if (got == .replied and got.replied) return;
return error.ServerWedged;
};
const outcome = race.await() catch {
race.cancelDiscard();
return error.ProbeCanceled;
};
race.cancelDiscard();
switch (outcome) {
.replied => |ok| if (!ok) return error.ServerBadReply,
.expired => return error.ServerWedged,
}
}
/// Prove a full sync round still converges after the abuse: clone the served
/// repo into a fresh tree and require its on-disk artifact set to equal the
/// server's (`expectSameDigestSet`) — the interop oracle, unweakened.
fn expectCloneConverges(gpa: std.mem.Allocator, io: std.Io, tmp_parent: *std.testing.TmpDir, url: []const u8, want: []const []const u8) !void {
var clone = try runZit(gpa, io, tmp_parent.dir, &.{ "clone", url, "recover" });
defer freeResult(gpa, &clone);
try expectExitDiag(clone.term, 0, clone);
var b_dir = try tmp_parent.dir.openDir(io, "recover", .{});
defer b_dir.close(io);
const got = try collectArtifactDigests(gpa, io, b_dir);
defer freeDigests(gpa, got);
try expectSameDigestSet(want, got);
}
/// The bounded ceiling for `expectServesFreshRequest`: a stalled connection is
/// abandoned by the serve deadline (`serve.default_conn_read_timeout_ns`, 5 s),
/// after which a fresh loopback request is answered in milliseconds. 15 s is 3×
/// that deadline — ample slack for a loaded runner while still bounding a true
/// wedge into a clean failure well inside the e2e step timeout.
const serve_probe_window_ns: u64 = 15_000_000_000;
/// Seed a one-commit repo in `dir` and return its artifact-digest set (the
/// convergence oracle). Caller frees via `freeDigests`.
fn seedServedRepo(gpa: std.mem.Allocator, io: std.Io, dir: std.Io.Dir) ![][]u8 {
try initRepo(gpa, io, dir);
try writeFile(io, dir, "seed.txt", "served content for robustness\n");
try addManaged(gpa, io, dir, &.{"seed.txt"});
var commit = try runCommitEnv(gpa, io, dir, .{ .user = "u" }, &.{ "commit", "-m", "seed" });
defer freeResult(gpa, &commit);
try expectExit(commit.term, 0);
return collectArtifactDigests(gpa, io, dir);
}
test "serve robustness: a byte-dribbled slow-loris head does not wedge the server" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp_a = std.testing.tmpDir(.{});
defer tmp_a.cleanup();
const a_digests = try seedServedRepo(gpa, io, tmp_a.dir);
defer freeDigests(gpa, a_digests);
const port = try freshLoopbackPort(io);
var server = try spawnServe(gpa, io, tmp_a.dir, port);
defer server.kill(io);
try waitForListen(io, port);
// Slow-loris: dribble a partial request head one byte per 50 ms and NEVER
// complete it, holding the connection open. Bounded: 8 bytes × 50 ms = 400 ms
// of dribble, then hold — the head terminator (\r\n\r\n) never arrives, so
// `receiveHead` on the server blocks until its deadline abandons it.
const loris = try dialServe(io, port);
defer loris.close(io);
{
var wbuf: [8]u8 = undefined;
var w = loris.writer(io, &wbuf);
const dribble = "POST /xf"; // a partial, never-terminated request head
for (dribble) |c| {
w.interface.writeByte(c) catch break;
w.interface.flush() catch break;
io.sleep(.{ .nanoseconds = 50_000_000 }, .awake) catch {};
}
}
// The server survives: a fresh request is answered within the bounded window
// (served only once the loris connection is abandoned by the deadline).
try expectServesFreshRequest(io, port, serve_probe_window_ns);
// And a full sync round still converges against the same live server.
const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
defer gpa.free(url);
try expectCloneConverges(gpa, io, &tmp_a, url, a_digests);
}
test "serve robustness: a valid head then a half-sent body does not wedge the server" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp_a = std.testing.tmpDir(.{});
defer tmp_a.cleanup();
const a_digests = try seedServedRepo(gpa, io, tmp_a.dir);
defer freeDigests(gpa, a_digests);
const port = try freshLoopbackPort(io);
var server = try spawnServe(gpa, io, tmp_a.dir, port);
defer server.kill(io);
try waitForListen(io, port);
// Send a COMPLETE, well-formed sync request head declaring a 100-byte body,
// then send only 50 bytes and HOLD. The server accepts the head, then blocks
// reading the remaining body bytes that never come, until the deadline.
const partial = try dialServe(io, port);
defer partial.close(io);
{
var wbuf: [256]u8 = undefined;
var w = partial.writer(io, &wbuf);
try w.interface.writeAll(
"POST /xfer HTTP/1.1\r\nHost: z\r\n" ++
"Content-Type: application/x-fossil\r\nContent-Length: 100\r\n" ++
"Connection: close\r\n\r\n",
);
try w.interface.writeAll(repeat("x", 50)); // half of the declared 100-byte body
try w.interface.flush();
}
try expectServesFreshRequest(io, port, serve_probe_window_ns);
const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
defer gpa.free(url);
try expectCloneConverges(gpa, io, &tmp_a, url, a_digests);
}
test "serve robustness: a client that disconnects mid-response does not wedge the server" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp_a = std.testing.tmpDir(.{});
defer tmp_a.cleanup();
const a_digests = try seedServedRepo(gpa, io, tmp_a.dir);
defer freeDigests(gpa, a_digests);
const port = try freshLoopbackPort(io);
var server = try spawnServe(gpa, io, tmp_a.dir, port);
defer server.kill(io);
try waitForListen(io, port);
// Send a complete well-formed request, then close the connection WITHOUT
// reading the reply — the peer vanishes while the server is answering. The
// server's write to a gone peer fails per-connection and the loop moves on.
{
const abrupt = try dialServe(io, port);
var wbuf: [128]u8 = undefined;
var w = abrupt.writer(io, &wbuf);
try w.interface.writeAll("GET /xfer HTTP/1.1\r\nHost: z\r\nConnection: close\r\n\r\n");
try w.interface.flush();
abrupt.close(io); // disconnect without draining the response
}
try expectServesFreshRequest(io, port, serve_probe_window_ns);
const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
defer gpa.free(url);
try expectCloneConverges(gpa, io, &tmp_a, url, a_digests);
}
test "serve robustness: a burst of idle connections that never send a byte does not wedge the server" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp_a = std.testing.tmpDir(.{});
defer tmp_a.cleanup();
const a_digests = try seedServedRepo(gpa, io, tmp_a.dir);
defer freeDigests(gpa, a_digests);
const port = try freshLoopbackPort(io);
var server = try spawnServe(gpa, io, tmp_a.dir, port);
defer server.kill(io);
try waitForListen(io, port);
// A burst of connections that connect and immediately give up without ever
// sending a byte. Each is a clean EOF the accept loop must drain and move
// past — a connection-churn peer must not pin or leak the server. Bounded:
// a fixed count, each opened and closed in turn (sequential, never held).
const idle_connections: u32 = 5;
var i: u32 = 0;
while (i < idle_connections) : (i += 1) {
const idle = try dialServe(io, port);
idle.close(io); // zero bytes sent, then gone
}
try expectServesFreshRequest(io, port, serve_probe_window_ns);
const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
defer gpa.free(url);
try expectCloneConverges(gpa, io, &tmp_a, url, a_digests);
}
/// POST `plain` to the served repository as an `application/x-fossil` sync
/// request and return the DECODED reply body (caller frees). Raw HTTP rather than
/// a `zit` subcommand because no verb emits a bare `gimme` for an arbitrary hash —
/// that card is what §3.3 L569-572's "If absent, silently skip" is about.
fn postXferPlain(gpa: std.mem.Allocator, io: std.Io, port: u16, plain: []const u8) ![]u8 {
const body = try container.encode(gpa, plain, .default);
defer gpa.free(body);
const stream = try dialServe(io, port);
defer stream.close(io);
{
var wbuf: [512]u8 = undefined;
var w = stream.writer(io, &wbuf);
const head = try std.fmt.allocPrint(
gpa,
"POST /xfer HTTP/1.1\r\nHost: z\r\nContent-Type: application/x-fossil\r\n" ++
"Content-Length: {d}\r\nConnection: close\r\n\r\n",
.{body.len},
);
defer gpa.free(head);
try w.interface.writeAll(head);
try w.interface.writeAll(body);
try w.interface.flush();
}
// Read to EOF (the server closed the connection), then split off the head. A
// READ FAULT is not end-of-stream: both callers assert on a name being ABSENT
// from the reply, which a truncated body satisfies for free, so a socket error
// must fail the test rather than shorten the body.
var rbuf: [4096]u8 = undefined;
var r = stream.reader(io, &rbuf);
const raw = try r.interface.allocRemaining(gpa, .limited(1 << 20));
defer gpa.free(raw);
const sep = std.mem.indexOf(u8, raw, "\r\n\r\n") orelse return error.NoHttpHeadEnd;
if (std.mem.indexOf(u8, raw[0..sep], " 200 ") == null) return error.NotOk;
return container.decode(gpa, raw[sep + 4 ..], 1 << 20);
}
test "cli serve: a slow-but-draining peer receives a multi-megabyte clone reply intact — the write deadline scales with the reply (at the §8.2 byte budget)" {
const gpa = std.testing.allocator;
const io = std.testing.io;
// A repo whose one clone batch approaches the §8.2 byte budget:
// deterministic incompressible blobs, so the reply body is multi-MiB and
// the server's write genuinely blocks on the peer draining it (loopback
// kernel buffering absorbs the first few hundred KiB for free).
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
var prng = std.Random.DefaultPrng.init(0x5eed_c0de);
const blob = try gpa.alloc(u8, 512 * 1024);
defer gpa.free(blob);
var names_buf: [8][16]u8 = undefined;
var i: usize = 0;
while (i < 8) : (i += 1) {
prng.random().bytes(blob);
const name = std.fmt.bufPrint(&names_buf[i], "blob{d}.bin", .{i}) catch unreachable;
try writeFile(io, tmp.dir, name, blob);
try addManaged(gpa, io, tmp.dir, &.{name});
}
var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "wide" });
defer freeResult(gpa, &commit);
try expectExit(commit.term, 0);
const port = try freshLoopbackPort(io);
var server = try spawnServe(gpa, io, tmp.dir, port);
defer server.kill(io);
try waitForListen(io, port);
// The raw clone opener a transport would send.
const req = try container.encode(gpa, "pragma client-version 1\nclone 3 1\n", .default);
defer gpa.free(req);
const stream = try dialServe(io, port);
defer stream.close(io);
{
var wbuf: [512]u8 = undefined;
var w = stream.writer(io, &wbuf);
const head = try std.fmt.allocPrint(
gpa,
"POST /xfer HTTP/1.1\r\nHost: z\r\nContent-Type: application/x-fossil\r\n" ++
"Content-Length: {d}\r\nConnection: close\r\n\r\n",
.{req.len},
);
defer gpa.free(head);
try w.interface.writeAll(head);
try w.interface.writeAll(req);
try w.interface.flush();
}
// Drain the reply THROTTLED to ~427 KiB/s — a healthy DSL-class peer.
// Over a ~4 MiB reply that is ~10 s of draining: far past the flat 5 s
// deadline (which used to cancel this healthy write mid-flight — the
// regression shape), comfortably above the scaled deadline's minimum
// drain rate. The whole body must arrive: a truncated reply is exactly
// the regression this test exists to catch.
var chunk: [64 * 1024]u8 = undefined;
var raw: std.ArrayList(u8) = .empty;
defer raw.deinit(gpa);
var rbuf: [4096]u8 = undefined;
var r = stream.reader(io, &rbuf);
while (true) {
const n = r.interface.readSliceShort(&chunk) catch break;
if (n == 0) break;
try raw.appendSlice(gpa, chunk[0..n]);
io.sleep(.{ .nanoseconds = 150 * std.time.ns_per_ms }, .awake) catch {};
}
// The head parsed 200 with a Content-Length the body honors in full.
const sep = std.mem.indexOf(u8, raw.items, "\r\n\r\n") orelse return error.NoHttpHeadEnd;
try std.testing.expect(std.mem.indexOf(u8, raw.items[0..sep], " 200 ") != null);
const cl_key = "content-length: ";
const head_lower = try std.ascii.allocLowerString(gpa, raw.items[0..sep]);
defer gpa.free(head_lower);
const cl_at = std.mem.indexOf(u8, head_lower, cl_key) orelse return error.NoContentLength;
const cl_end = std.mem.indexOfScalarPos(u8, head_lower, cl_at, '\r') orelse return error.NoContentLength;
const content_length = try std.fmt.parseInt(usize, head_lower[cl_at + cl_key.len .. cl_end], 10);
// The batch really was multi-MiB — the premise that makes the write block.
try std.testing.expect(content_length >= 3 << 20);
try std.testing.expectEqual(content_length, raw.items.len - (sep + 4));
}
test "cli serve: a --force shun's generation swap is served on the next round — the live server reopens the renamed store, no restart" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp_a = std.testing.tmpDir(.{});
defer tmp_a.cleanup();
const root = try shunFixture(gpa, io, tmp_a.dir);
defer gpa.free(root);
const doomed = try artifactNameByContent(gpa, io, tmp_a.dir, doomed_body);
defer gpa.free(doomed);
const kept = try artifactNameByContent(gpa, io, tmp_a.dir, kept_body);
defer gpa.free(kept);
// ONE server for the whole test: the point is what happens without a restart.
const port = try freshLoopbackPort(io);
var server = try spawnServe(gpa, io, tmp_a.dir, port);
defer server.kill(io);
try waitForListen(io, port);
const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
defer gpa.free(url);
// Before the shun: a clone receives the doomed artifact — the premise.
{
var clone = try runZit(gpa, io, tmp_a.dir, &.{ "clone", url, "before" });
defer freeResult(gpa, &clone);
try expectExitDiag(clone.term, 0, clone);
var b_dir = try tmp_a.dir.openDir(io, "before", .{});
defer b_dir.close(io);
try std.testing.expect(try storeHoldsArtifact(gpa, io, b_dir, doomed));
}
// The takedown: --force reclaims by RENAMING a new generation over `.zit`.
// The running server still holds the old inode's handle.
{
var res = try runZit(gpa, io, tmp_a.dir, &.{ "shun", "--force", doomed });
defer freeResult(gpa, &res);
try expectExitDiag(res.term, 0, res);
}
try std.testing.expect(!try storeHoldsArtifact(gpa, io, tmp_a.dir, doomed));
// The very next round serves the rewritten generation: the doomed bytes are
// gone from a fresh clone, the kept artifact still arrives — no restart.
{
var clone = try runZit(gpa, io, tmp_a.dir, &.{ "clone", "--no-open", url, "after" });
defer freeResult(gpa, &clone);
try expectExitDiag(clone.term, 0, clone);
var b_dir = try tmp_a.dir.openDir(io, "after", .{});
defer b_dir.close(io);
try std.testing.expect(!try storeHoldsArtifact(gpa, io, b_dir, doomed));
try std.testing.expect(try storeHoldsArtifact(gpa, io, b_dir, kept));
}
}
test "cli serve §9.1: the clone reply's push card carries a real derived servercode, not the placeholder" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "a.txt", "one\n");
try addManaged(gpa, io, tmp.dir, &.{"a.txt"});
var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "seed" });
defer freeResult(gpa, &commit);
try expectExit(commit.term, 0);
const port = try freshLoopbackPort(io);
var server = try spawnServe(gpa, io, tmp.dir, port);
defer server.kill(io);
try waitForListen(io, port);
// A clone reply rides UNCOMPRESSED (§8.1), so read the raw body rather
// than routing through the container-decoding helper.
const req = try container.encode(gpa, "pragma client-version 1\nclone 3 1\n", .default);
defer gpa.free(req);
const stream = try dialServe(io, port);
defer stream.close(io);
{
var wbuf: [512]u8 = undefined;
var w = stream.writer(io, &wbuf);
const head = try std.fmt.allocPrint(
gpa,
"POST /xfer HTTP/1.1\r\nHost: z\r\nContent-Type: application/x-fossil\r\n" ++
"Content-Length: {d}\r\nConnection: close\r\n\r\n",
.{req.len},
);
defer gpa.free(head);
try w.interface.writeAll(head);
try w.interface.writeAll(req);
try w.interface.flush();
}
var rbuf: [4096]u8 = undefined;
var r = stream.reader(io, &rbuf);
const raw = try r.interface.allocRemaining(gpa, .limited(1 << 20));
defer gpa.free(raw);
const sep = std.mem.indexOf(u8, raw, "\r\n\r\n") orelse return error.NoHttpHeadEnd;
try std.testing.expect(std.mem.indexOf(u8, raw[0..sep], " 200 ") != null);
const reply = raw[sep + 4 ..];
const at = std.mem.indexOf(u8, reply, "\npush ") orelse return error.NoPushCard;
const line_end = std.mem.indexOfScalarPos(u8, reply, at + 1, '\n') orelse return error.NoPushCard;
const line = reply[at + 1 .. line_end];
var toks = std.mem.tokenizeScalar(u8, line, ' ');
_ = toks.next(); // "push"
const servercode = toks.next() orelse return error.NoPushCard;
// Real identity: 40 lowercase hex, and not the informational placeholder.
try std.testing.expectEqual(@as(usize, 40), servercode.len);
for (servercode) |c| try std.testing.expect(std.ascii.isHex(c) and !std.ascii.isUpper(c));
try std.testing.expect(!std.mem.eql(u8, servercode, "0000000000000000"));
try std.testing.expect(std.mem.indexOf(u8, servercode, "00000000") == null or !std.mem.allEqual(u8, servercode, '0'));
}
test "cli serve: a shunned holding is never igot-announced, and an inbound gimme for it is silently skipped (sync §9.5 L2170-2174, §3.3 L569-572)" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp_a = std.testing.tmpDir(.{});
defer tmp_a.cleanup();
const root = try shunFixture(gpa, io, tmp_a.dir);
defer gpa.free(root);
const doomed = try artifactNameByContent(gpa, io, tmp_a.dir, doomed_body);
defer gpa.free(doomed);
const kept = try artifactNameByContent(gpa, io, tmp_a.dir, kept_body);
defer gpa.free(kept);
{
var res = try runZit(gpa, io, tmp_a.dir, &.{ "shun", "--force", "--defer", doomed });
defer freeResult(gpa, &res);
try expectExitDiag(res.term, 0, res);
}
// Premise again: the server still HOLDS the bytes it must refuse to send.
try std.testing.expect(try storeHoldsArtifact(gpa, io, tmp_a.dir, doomed));
// §8.5 — both rounds pull as a peer of the served project.
const pcode = try readProjectCode(gpa, io, tmp_a.dir);
defer gpa.free(pcode);
const port = try freshLoopbackPort(io);
var server = try spawnServe(gpa, io, tmp_a.dir, port);
defer server.kill(io);
try waitForListen(io, port);
// ROUND 1 — the §3.2/§9.5 INVENTORY WALK. The client announces a hash this
// repo does not hold, so the server answers with igot for "every eligible
// holding after the Section 3.3 shun … filters" (§9.5 L2171-2173). The
// unshunned neighbour proves the walk ran at all, so the shunned name's
// absence is the filter and not an empty reply.
{
const absent = try gpa.alloc(u8, doomed.len);
defer gpa.free(absent);
@memset(absent, '0');
const plain = try std.fmt.allocPrint(gpa, "pragma client-version 20000\npull sc {s}\nigot {s}\n", .{ pcode, absent });
defer gpa.free(plain);
const reply = try postXferPlain(gpa, io, port, plain);
defer gpa.free(reply);
const kept_igot = try std.fmt.allocPrint(gpa, "igot {s}\n", .{kept});
defer gpa.free(kept_igot);
try std.testing.expect(std.mem.indexOf(u8, reply, kept_igot) != null);
// The shunned name appears on NO card — not igot (it is not an eligible
// holding), not gimme (§3.3 L553-556 excludes it from the phantom scan),
// and above all not `error`.
try std.testing.expect(std.mem.indexOf(u8, reply, doomed) == null);
try std.testing.expect(std.mem.indexOf(u8, reply, "error") == null);
}
// ROUND 2 — an inbound `gimme` for the shunned hash. §3.3 L569-572: "If
// absent, silently skip." The mask is what makes it absent to the
// enumeration, so this needs no code of its own on the gimme path.
{
const plain = try std.fmt.allocPrint(
gpa,
"pragma client-version 20000\npull sc {s}\ngimme {s}\ngimme {s}\n",
.{ pcode, doomed, kept },
);
defer gpa.free(plain);
const reply = try postXferPlain(gpa, io, port, plain);
defer gpa.free(reply);
// The neighbour comes back as a `file` card…
const kept_card = try std.fmt.allocPrint(gpa, "file {s} ", .{kept});
defer gpa.free(kept_card);
try std.testing.expect(std.mem.indexOf(u8, reply, kept_card) != null);
// …and the shunned hash produces nothing at all, error card included.
try std.testing.expect(std.mem.indexOf(u8, reply, doomed) == null);
try std.testing.expect(std.mem.indexOf(u8, reply, "error") == null);
}
}
// --- RECEIVE-side admission through the real binary (sync §7.7 L1469-1490) --
//
// The send-side filter above keeps a shunned artifact off the wire when WE are
// the sender. This is the other direction, and the one a shun is worthless
// without: a PEER pushes the shunned artifact AT us. §7.7 L1472-1475 — "A
// non-clone file whose target is shunned is consumed and discarded after its
// payload and pending private marker; it emits no error, does not set
// content-received, and makes no repository mutation." A server under
// push-receive is always non-clone, so this is the discard arm, unconditionally.
//
// WHY A RAW POST AND NOT `zit push`. A zit-to-zit push cannot reach this code at
// all: the receiving server's §3.3 L553-556 phantom scan already declines to
// `gimme` a shunned name, and a zit push client only uploads what the peer asked
// for — so the send-side filter masks the receive-side gap end to end, and a
// `zit push` e2e passes with the whole admission check deleted (checked, not
// assumed). A real Fossil push is UNSOLICITED: it sends the content its own
// inventory says the peer lacks. `postXferPlain` is that shape, and it is the
// only shape that puts the receive path under test.
//
// The shun is `--force`, so A does not hold the bytes: the ONLY thing that can
// keep them out is admission at ingest.
test "cli serve: an unsolicited push of a shunned artifact is discarded — nothing lands and no error card comes back (sync §7.7 L1472-1475)" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp_a = std.testing.tmpDir(.{});
defer tmp_a.cleanup();
const root = try shunFixture(gpa, io, tmp_a.dir);
defer gpa.free(root);
const doomed = try artifactNameByContent(gpa, io, tmp_a.dir, doomed_body);
defer gpa.free(doomed);
{
var res = try runZit(gpa, io, tmp_a.dir, &.{ "shun", "--force", doomed });
defer freeResult(gpa, &res);
try expectExitDiag(res.term, 0, res);
}
// The premise: the operator's removal actually happened.
try std.testing.expect(!try storeHoldsArtifact(gpa, io, tmp_a.dir, doomed));
const port = try freshLoopbackPort(io);
var server = try spawnServe(gpa, io, tmp_a.dir, port);
defer server.kill(io);
try waitForListen(io, port);
// §9.1 — a `push SERVERCODE PROJECTCODE` card naming the served project
// (§8.5), then the artifact itself, sent without ever having been asked for.
const pcode = try readProjectCode(gpa, io, tmp_a.dir);
defer gpa.free(pcode);
const plain = try std.fmt.allocPrint(
gpa,
"pragma client-version 20000\npush {s} {s}\nfile {s} {d}\n{s}",
.{ repeat("1", 40), pcode, doomed, doomed_body.len, doomed_body },
);
defer gpa.free(plain);
const reply = try postXferPlain(gpa, io, port, plain);
defer gpa.free(reply);
// "it emits no error" — no error card of any kind, and the shunned name is
// not echoed back on one either.
try std.testing.expect(std.mem.indexOf(u8, reply, "error") == null);
try std.testing.expect(std.mem.indexOf(u8, reply, doomed) == null);
// The SAME card in DELTA form (§7.1 `file HASH DELTASRC SIZE`), against a
// basis this repository does not hold. That is the COMMON shape for a
// shunned target — its neighbours are unlikely to still be here — and it is
// the one that reaches the server's delta reconstruction. L1437-1440 draws no
// distinction between the two forms: still no error card, still nothing
// lands. The delta payload is deliberately junk; the basis lookup fails
// before it is parsed, so the path is deterministic either way.
const delta_plain = try std.fmt.allocPrint(
gpa,
"pragma client-version 20000\npush {s} {s}\nfile {s} {s} 4\njunk",
.{ repeat("1", 40), pcode, doomed, repeat("3", 64) },
);
defer gpa.free(delta_plain);
const delta_reply = try postXferPlain(gpa, io, port, delta_plain);
defer gpa.free(delta_reply);
try std.testing.expect(std.mem.indexOf(u8, delta_reply, "error") == null);
try std.testing.expect(std.mem.indexOf(u8, delta_reply, doomed) == null);
// "makes no repository mutation" — not even the DELTASRC phantom, because
// admission is decided before DELTASRC is looked at (L1434-1435).
try std.testing.expect(std.mem.indexOf(u8, delta_reply, repeat("3", 64)) == null);
// THE PROOF: release the server's handles, then read A back off disk. The
// repository the operator emptied is still empty of it.
server.kill(io);
try std.testing.expect(!try storeHoldsArtifact(gpa, io, tmp_a.dir, doomed));
}
test "cli serve --read-only: a peer clones and pulls, its push is refused, and nothing it pushed is stored" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp_a = std.testing.tmpDir(.{});
defer tmp_a.cleanup();
try initRepo(gpa, io, tmp_a.dir);
try writeFile(io, tmp_a.dir, "a.txt", "a\n");
try addManaged(gpa, io, tmp_a.dir, &.{"a.txt"});
var first = try runCommitEnv(gpa, io, tmp_a.dir, .{ .user = "u" }, &.{ "commit", "-m", "first" });
defer freeResult(gpa, &first);
try expectExitDiag(first.term, 0, first);
const port = try freshLoopbackPort(io);
var server = try spawnServeFlag(gpa, io, tmp_a.dir, port, "--read-only");
defer server.kill(io);
try waitForListen(io, port);
const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
defer gpa.free(url);
var tmp_b = std.testing.tmpDir(.{});
defer tmp_b.cleanup();
var clone = try runZit(gpa, io, tmp_b.dir, &.{ "clone", url, "cl" });
defer freeResult(gpa, &clone);
try expectExitDiag(clone.term, 0, clone);
var cl = try tmp_b.dir.openDir(io, "cl", .{});
defer cl.close(io);
try writeFile(io, cl, "b.txt", "b\n");
try addManaged(gpa, io, cl, &.{"b.txt"});
var stranger = try runCommitEnv(gpa, io, cl, .{ .user = "s" }, &.{ "commit", "-m", "stranger", "--no-sync" });
defer freeResult(gpa, &stranger);
try expectExitDiag(stranger.term, 0, stranger);
var push = try runZit(gpa, io, cl, &.{ "push", url });
defer freeResult(gpa, &push);
try expectExit(push.term, 1);
var tl = try runZit(gpa, io, tmp_a.dir, &.{ "timeline", "-n", "5" });
defer freeResult(gpa, &tl);
try std.testing.expect(std.mem.indexOf(u8, tl.stdout, "stranger") == null);
// A pull still answers: a check-in made at the server reaches the clone.
try writeFile(io, tmp_a.dir, "a.txt", "a2\n");
var second = try runCommitEnv(gpa, io, tmp_a.dir, .{ .user = "u" }, &.{ "commit", "-m", "second" });
defer freeResult(gpa, &second);
try expectExitDiag(second.term, 0, second);
var pull = try runZit(gpa, io, cl, &.{ "pull", url });
defer freeResult(gpa, &pull);
// "second" lands beside the clone's unpushed "stranger": a fork the pull
// brought, so the pull succeeds with the fork status.
try expectExitDiag(pull.term, 9, pull);
try expectContains(pull.stderr, "fork on trunk: 2 leaves (");
var cl_tl = try runZit(gpa, io, cl, &.{ "timeline", "-n", "5" });
defer freeResult(gpa, &cl_tl);
try std.testing.expect(std.mem.indexOf(u8, cl_tl.stdout, "second") != null);
}
test "cli serve on a sparse store: dense and uncovered clones refuse, a covered cone clone succeeds" {
// Goal: section 5.3 -- a sparse origin refuses to serve clones it does
// not cover (dense requests and cones outside its coverage) with one
// error card and zero content bytes; a clone wholly inside its cone is
// served. Method: build a dense repo, clone --cone=src into B, serve B,
// then attempt the three clone shapes against it.
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp_a = std.testing.tmpDir(.{});
defer tmp_a.cleanup();
try initRepo(gpa, io, tmp_a.dir);
try tmp_a.dir.createDir(io, "src", .default_dir);
try tmp_a.dir.createDir(io, "tools", .default_dir);
try writeFile(io, tmp_a.dir, "src/a.zig", "in\n");
try writeFile(io, tmp_a.dir, "tools/t.bin", "out\n");
try addManaged(gpa, io, tmp_a.dir, &.{ "src/a.zig", "tools/t.bin" });
var c1 = try runCommitEnv(gpa, io, tmp_a.dir, .{ .user = "u" }, &.{ "commit", "-m", "seed" });
defer freeResult(gpa, &c1);
try expectExit(c1.term, 0);
const port_a = try freshLoopbackPort(io);
var server_a = try spawnServe(gpa, io, tmp_a.dir, port_a);
defer server_a.kill(io);
try waitForListen(io, port_a);
const url_a = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port_a});
defer gpa.free(url_a);
var tmp_b = std.testing.tmpDir(.{});
defer tmp_b.cleanup();
var clone_b = try runZit(gpa, io, tmp_b.dir, &.{ "clone", "--cone=src", url_a, "repo" });
defer freeResult(gpa, &clone_b);
try expectExitDiag(clone_b.term, 0, clone_b);
var b_dir = try tmp_b.dir.openDir(io, "repo", .{});
defer b_dir.close(io);
const port_b = try freshLoopbackPort(io);
var server_b = try spawnServe(gpa, io, b_dir, port_b);
defer server_b.kill(io);
try waitForListen(io, port_b);
const url_b = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port_b});
defer gpa.free(url_b);
var tmp_c = std.testing.tmpDir(.{});
defer tmp_c.cleanup();
// A dense clone from the sparse origin refuses.
var dense = try runZit(gpa, io, tmp_c.dir, &.{ "clone", url_b, "dense" });
defer freeResult(gpa, &dense);
try expectNonzeroExit(dense.term);
// An uncovered cone refuses the same way.
var wide = try runZit(gpa, io, tmp_c.dir, &.{ "clone", "--cone=tools", url_b, "wide" });
defer freeResult(gpa, &wide);
try expectNonzeroExit(wide.term);
// A cone inside the origin's coverage is served.
var narrow = try runZit(gpa, io, tmp_c.dir, &.{ "clone", "--no-open", "--cone=src", url_b, "narrow" });
defer freeResult(gpa, &narrow);
try expectExitDiag(narrow.term, 0, narrow);
var n_dir = try tmp_c.dir.openDir(io, "narrow", .{});
defer n_dir.close(io);
var op = try runZit(gpa, io, n_dir, &.{ "open", "--cone=src" });
defer freeResult(gpa, &op);
try expectExitDiag(op.term, 0, op);
try std.testing.expect(fileExists(io, n_dir, "src/a.zig"));
}
/// Every artifact `dir` holds that `except` does not, as push
/// `file` cards, read through `zit frames` (whose framing is the push card's
/// own: a header line, then exactly SIZE raw bytes).
fn pushCardsFrom(gpa: std.mem.Allocator, io: std.Io, dir: std.Io.Dir, except: []const []const u8) ![]u8 {
var frames = try runZit(gpa, io, dir, &.{"frames"});
defer freeResult(gpa, &frames);
try expectExitDiag(frames.term, 0, frames);
const out = frames.stdout;
var cards: std.ArrayListUnmanaged(u8) = .empty;
errdefer cards.deinit(gpa);
var pos: usize = 0;
while (pos < out.len) {
const nl = std.mem.indexOfScalarPos(u8, out, pos, '\n') orelse break;
const line = out[pos..nl];
pos = nl + 1;
if (std.mem.startsWith(u8, line, "cursor ")) break;
if (!std.mem.startsWith(u8, line, "artifact ")) continue;
var it = std.mem.tokenizeScalar(u8, line["artifact ".len..], ' ');
const hash = it.next() orelse return error.TestUnexpectedResult;
const size = try std.fmt.parseInt(usize, it.next() orelse return error.TestUnexpectedResult, 10);
if (pos + size > out.len) return error.TestUnexpectedResult;
const bytes = out[pos .. pos + size];
pos += size;
if (pos < out.len and out[pos] == '\n') pos += 1;
// `except` holds raw digests, the frames listing prints hex: compare
// in one alphabet or nothing is ever excluded and every held artifact
// rides the push again.
var skip = false;
for (except) |e| {
if (e.len == 32 and std.mem.eql(u8, &std.fmt.bytesToHex(e[0..32].*, .lower), hash)) skip = true;
if (std.mem.eql(u8, e, hash)) skip = true;
}
if (skip) continue;
var header: [128]u8 = undefined;
try cards.appendSlice(gpa, try std.fmt.bufPrint(&header, "file {s} {d}\n", .{ hash, size }));
try cards.appendSlice(gpa, bytes);
}
return cards.toOwnedSlice(gpa);
}
fn projectCodeOf(gpa: std.mem.Allocator, io: std.Io, dir: std.Io.Dir) ![]u8 {
var stat = try runZit(gpa, io, dir, &.{"stat"});
defer freeResult(gpa, &stat);
try expectExitDiag(stat.term, 0, stat);
var lines = std.mem.tokenizeScalar(u8, stat.stdout, '\n');
while (lines.next()) |l| {
if (std.mem.startsWith(u8, l, "project-code ")) return gpa.dupe(u8, std.mem.trim(u8, l["project-code ".len..], " "));
}
return error.TestUnexpectedResult;
}
fn hasDigest(set: []const []const u8, want: []const u8) bool {
for (set) |d| if (std.mem.eql(u8, d, want)) return true;
return false;
}
test "cli serve: a fronted server refuses a push that would join a protected branch and stores nothing; without --fronted the header is ignored" {
const gpa = std.testing.allocator;
const io = std.testing.io;
// A: the served repository, one seed check-in on trunk.
var tmp_a = std.testing.tmpDir(.{});
defer tmp_a.cleanup();
try initRepo(gpa, io, tmp_a.dir);
try writeFile(io, tmp_a.dir, "one.txt", "seed\n");
try addManaged(gpa, io, tmp_a.dir, &.{"one.txt"});
var seed = try runCommitEnv(gpa, io, tmp_a.dir, .{ .user = "u" }, &.{ "commit", "-m", "seed" });
defer freeResult(gpa, &seed);
try expectExit(seed.term, 0);
// B: a clone that grows by one trunk check-in — the thing to be refused.
const clone_port = try freshLoopbackPort(io);
var clone_server = try spawnServe(gpa, io, tmp_a.dir, clone_port);
try waitForListen(io, clone_port);
const clone_url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/xfer", .{clone_port});
defer gpa.free(clone_url);
var tmp_b = std.testing.tmpDir(.{});
defer tmp_b.cleanup();
var clone = try runZit(gpa, io, tmp_b.dir, &.{ "clone", clone_url, "repo" });
defer freeResult(gpa, &clone);
try expectExitDiag(clone.term, 0, clone);
clone_server.kill(io);
var b_repo = try tmp_b.dir.openDir(io, "repo", .{});
defer b_repo.close(io);
try writeFile(io, b_repo, "two.txt", "grows trunk\n");
try addManaged(gpa, io, b_repo, &.{"two.txt"});
var grow = try runCommitEnv(gpa, io, b_repo, .{ .user = "u" }, &.{ "commit", "-m", "grow" });
defer freeResult(gpa, &grow);
try expectExit(grow.term, 0);
const a_before = try collectArtifactDigests(gpa, io, tmp_a.dir);
defer freeDigests(gpa, a_before);
const b_all = try collectArtifactDigests(gpa, io, b_repo);
defer freeDigests(gpa, b_all);
try std.testing.expect(b_all.len > a_before.len);
// The push B's client would send, as raw cards, so a header can ride it.
const files = try pushCardsFrom(gpa, io, b_repo, a_before);
defer gpa.free(files);
const project = try projectCodeOf(gpa, io, b_repo);
defer gpa.free(project);
const request = try std.fmt.allocPrint(gpa, "pragma client-version 20000\npush {s} {s}\n{s}", .{ repeat("c", 40), project, files });
defer gpa.free(request);
// Fronted, with the front's rule: refused, naming trunk, and A is byte-for-
// byte what it was.
{
const port = try freshLoopbackPort(io);
var server = try spawnServeFronted(gpa, io, tmp_a.dir, port, true);
defer server.kill(io);
try waitForListen(io, port);
const reply = try postXferCardsHeaders(gpa, io, port, request, "X-Zit-Protect: trunk\r\n");
defer gpa.free(reply);
try std.testing.expect(std.mem.startsWith(u8, reply, "error "));
try std.testing.expect(std.mem.indexOf(u8, reply, "'trunk'") != null);
server.kill(io);
const a_after = try collectArtifactDigests(gpa, io, tmp_a.dir);
defer freeDigests(gpa, a_after);
try std.testing.expectEqual(a_before.len, a_after.len);
}
// Not fronted, same header: ignored. The push lands and A holds B's set.
{
const port = try freshLoopbackPort(io);
var server = try spawnServe(gpa, io, tmp_a.dir, port);
defer server.kill(io);
try waitForListen(io, port);
const reply = try postXferCardsHeaders(gpa, io, port, request, "X-Zit-Protect: trunk\r\n");
defer gpa.free(reply);
try std.testing.expect(!std.mem.startsWith(u8, reply, "error "));
server.kill(io);
const a_after = try collectArtifactDigests(gpa, io, tmp_a.dir);
defer freeDigests(gpa, a_after);
for (b_all) |d| try std.testing.expect(hasDigest(a_after, d));
}
}
test "cli serve: a refused check-in amended onto another branch lands there, while a held trunk check-in still cannot be moved" {
// After a refused push the obvious recovery is `zit amend X --branch other`,
// which cancels `sym-trunk` on X from a control artifact. A cancel aimed at
// a check-in the server does not hold removes it from nothing held, so it is
// admitted and X is judged by where it joins — with the move applied, since
// the two travel in one round. Before this, the cancel was refused by name
// alone and every later push from that checkout carried the same refused
// round: a dead end only a fresh clone escaped.
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp_a = std.testing.tmpDir(.{});
defer tmp_a.cleanup();
try initRepo(gpa, io, tmp_a.dir);
try writeFile(io, tmp_a.dir, "one.txt", "seed\n");
try addManaged(gpa, io, tmp_a.dir, &.{"one.txt"});
const seed = try commitHashDup(gpa, io, tmp_a.dir, "seed");
defer gpa.free(seed);
const clone_port = try freshLoopbackPort(io);
var clone_server = try spawnServe(gpa, io, tmp_a.dir, clone_port);
try waitForListen(io, clone_port);
const clone_url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/xfer", .{clone_port});
defer gpa.free(clone_url);
var tmp_b = std.testing.tmpDir(.{});
defer tmp_b.cleanup();
var clone = try runZit(gpa, io, tmp_b.dir, &.{ "clone", clone_url, "repo" });
defer freeResult(gpa, &clone);
try expectExitDiag(clone.term, 0, clone);
clone_server.kill(io);
var b_repo = try tmp_b.dir.openDir(io, "repo", .{});
defer b_repo.close(io);
try writeFile(io, b_repo, "two.txt", "grows trunk\n");
try addManaged(gpa, io, b_repo, &.{"two.txt"});
const grow = try commitHashDup(gpa, io, b_repo, "grow");
defer gpa.free(grow);
const a_before = try collectArtifactDigests(gpa, io, tmp_a.dir);
defer freeDigests(gpa, a_before);
const project = try projectCodeOf(gpa, io, b_repo);
defer gpa.free(project);
// The recovery: move the refused check-in, then push the same set again.
// Strictly later than the pinned check-in time: a retag that ties its
// target's timestamp does not win, in fossil or here.
var am = try runCommitEnv(gpa, io, b_repo, .{ .user = "u", .epoch = "1234567891" }, &.{ "amend", grow, "--branch", "other" });
defer freeResult(gpa, &am);
try expectExitDiag(am.term, 0, am);
{
const files = try pushCardsFrom(gpa, io, b_repo, a_before);
defer gpa.free(files);
const request = try std.fmt.allocPrint(gpa, "pragma client-version 20000\npush {s} {s}\n{s}", .{ repeat("c", 40), project, files });
defer gpa.free(request);
const port = try freshLoopbackPort(io);
var server = try spawnServeFronted(gpa, io, tmp_a.dir, port, true);
defer server.kill(io);
try waitForListen(io, port);
const reply = try postXferCardsHeaders(gpa, io, port, request, "X-Zit-Protect: trunk\r\n");
defer gpa.free(reply);
try std.testing.expect(!std.mem.startsWith(u8, reply, "error "));
server.kill(io);
}
// A holds the check-in on `other`, and trunk's tip is still the seed.
{
var info = try runZit(gpa, io, tmp_a.dir, &.{ "info", grow });
defer freeResult(gpa, &info);
try expectExitDiag(info.term, 0, info);
try std.testing.expect(std.mem.indexOf(u8, info.stdout, "branch: other\n") != null);
const trunk_tip = try tipHashOf(gpa, io, tmp_a.dir, "trunk");
defer gpa.free(trunk_tip);
try std.testing.expectEqualStrings(seed, trunk_tip);
}
// Not a loosening: the same move on a check-in A HOLDS on trunk is still
// refused, because cancelling its sym is exactly how it would leave.
const a_mid = try collectArtifactDigests(gpa, io, tmp_a.dir);
defer freeDigests(gpa, a_mid);
var am2 = try runCommitEnv(gpa, io, b_repo, .{ .user = "u", .epoch = "1234567892" }, &.{ "amend", seed, "--branch", "other" });
defer freeResult(gpa, &am2);
try expectExitDiag(am2.term, 0, am2);
{
const files = try pushCardsFrom(gpa, io, b_repo, a_mid);
defer gpa.free(files);
const request = try std.fmt.allocPrint(gpa, "pragma client-version 20000\npush {s} {s}\n{s}", .{ repeat("c", 40), project, files });
defer gpa.free(request);
const port = try freshLoopbackPort(io);
var server = try spawnServeFronted(gpa, io, tmp_a.dir, port, true);
defer server.kill(io);
try waitForListen(io, port);
const reply = try postXferCardsHeaders(gpa, io, port, request, "X-Zit-Protect: trunk\r\n");
defer gpa.free(reply);
try std.testing.expect(std.mem.startsWith(u8, reply, "error "));
try std.testing.expect(std.mem.indexOf(u8, reply, "'trunk'") != null);
server.kill(io);
const a_after = try collectArtifactDigests(gpa, io, tmp_a.dir);
defer freeDigests(gpa, a_after);
try std.testing.expectEqual(a_mid.len, a_after.len);
}
}
test "cli serve: a branch check-in amended onto a protected branch is refused, and amended off it again lands" {
// The pusher's own move onto trunk travels with every later push, so the
// way out has to be judged by where the check-in ends up after all of its
// moves, newest winning, the way the derive itself will place it. Judged
// by the moves' names alone, the move onto trunk refused every push from
// that checkout.
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp_a = std.testing.tmpDir(.{});
defer tmp_a.cleanup();
try initRepo(gpa, io, tmp_a.dir);
try writeFile(io, tmp_a.dir, "one.txt", "seed\n");
try addManaged(gpa, io, tmp_a.dir, &.{"one.txt"});
const seed = try commitHashDup(gpa, io, tmp_a.dir, "seed");
defer gpa.free(seed);
const clone_port = try freshLoopbackPort(io);
var clone_server = try spawnServe(gpa, io, tmp_a.dir, clone_port);
try waitForListen(io, clone_port);
const clone_url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/xfer", .{clone_port});
defer gpa.free(clone_url);
var tmp_b = std.testing.tmpDir(.{});
defer tmp_b.cleanup();
var clone = try runZit(gpa, io, tmp_b.dir, &.{ "clone", clone_url, "repo" });
defer freeResult(gpa, &clone);
try expectExitDiag(clone.term, 0, clone);
clone_server.kill(io);
var b_repo = try tmp_b.dir.openDir(io, "repo", .{});
defer b_repo.close(io);
try writeFile(io, b_repo, "two.txt", "on a branch\n");
try addManaged(gpa, io, b_repo, &.{"two.txt"});
var ci = try runCommitEnv(gpa, io, b_repo, .{ .user = "u", .epoch = "1234567891" }, &.{ "commit", "-m", "feature work", "--branch", "feat" });
defer freeResult(gpa, &ci);
try expectExitDiag(ci.term, 0, ci);
const work = try gpa.dupe(u8, try checkinHash(ci.stdout));
defer gpa.free(work);
const a_before = try collectArtifactDigests(gpa, io, tmp_a.dir);
defer freeDigests(gpa, a_before);
const project = try projectCodeOf(gpa, io, b_repo);
defer gpa.free(project);
var onto = try runCommitEnv(gpa, io, b_repo, .{ .user = "u", .epoch = "1234567892" }, &.{ "amend", work, "--branch", "trunk" });
defer freeResult(gpa, &onto);
try expectExitDiag(onto.term, 0, onto);
const refused = try pushProtected(gpa, io, tmp_a.dir, b_repo, a_before, project);
defer gpa.free(refused);
try std.testing.expect(std.mem.startsWith(u8, refused, "error "));
try std.testing.expect(std.mem.indexOf(u8, refused, "'trunk'") != null);
{
const a_after = try collectArtifactDigests(gpa, io, tmp_a.dir);
defer freeDigests(gpa, a_after);
try std.testing.expectEqual(a_before.len, a_after.len);
}
var off = try runCommitEnv(gpa, io, b_repo, .{ .user = "u", .epoch = "1234567893" }, &.{ "amend", work, "--branch", "other" });
defer freeResult(gpa, &off);
try expectExitDiag(off.term, 0, off);
const landed = try pushProtected(gpa, io, tmp_a.dir, b_repo, a_before, project);
defer gpa.free(landed);
try std.testing.expect(!std.mem.startsWith(u8, landed, "error "));
{
var info = try runZit(gpa, io, tmp_a.dir, &.{ "info", work });
defer freeResult(gpa, &info);
try expectExitDiag(info.term, 0, info);
try std.testing.expect(std.mem.indexOf(u8, info.stdout, "branch: other\n") != null);
const trunk_tip = try tipHashOf(gpa, io, tmp_a.dir, "trunk");
defer gpa.free(trunk_tip);
try std.testing.expectEqualStrings(seed, trunk_tip);
}
}
test "cli serve: a fronted divert refuses a push onto trunk once, then keeps it on an attempt branch and tells the front" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp_a = std.testing.tmpDir(.{});
defer tmp_a.cleanup();
try initRepo(gpa, io, tmp_a.dir);
try writeFile(io, tmp_a.dir, "one.txt", "seed\n");
try addManaged(gpa, io, tmp_a.dir, &.{"one.txt"});
const seed = try commitHashDup(gpa, io, tmp_a.dir, "seed");
defer gpa.free(seed);
const clone_port = try freshLoopbackPort(io);
var clone_server = try spawnServe(gpa, io, tmp_a.dir, clone_port);
try waitForListen(io, clone_port);
const clone_url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/xfer", .{clone_port});
defer gpa.free(clone_url);
var tmp_b = std.testing.tmpDir(.{});
defer tmp_b.cleanup();
var clone = try runZit(gpa, io, tmp_b.dir, &.{ "clone", clone_url, "repo" });
defer freeResult(gpa, &clone);
try expectExitDiag(clone.term, 0, clone);
clone_server.kill(io);
var b_repo = try tmp_b.dir.openDir(io, "repo", .{});
defer b_repo.close(io);
try writeFile(io, b_repo, "two.txt", "grows trunk\n");
try addManaged(gpa, io, b_repo, &.{"two.txt"});
const grow = try commitHashDup(gpa, io, b_repo, "grow");
defer gpa.free(grow);
const a_before = try collectArtifactDigests(gpa, io, tmp_a.dir);
defer freeDigests(gpa, a_before);
const project = try projectCodeOf(gpa, io, b_repo);
defer gpa.free(project);
const headers = "X-Zit-Protect: trunk\r\nX-Zit-Divert-Login: jan\r\n";
{
const got = try pushProtectedHead(gpa, io, tmp_a.dir, b_repo, a_before, project, headers);
defer gpa.free(got.head);
defer gpa.free(got.body);
try std.testing.expect(std.mem.startsWith(u8, got.body, "error "));
try std.testing.expect(std.mem.indexOf(u8, got.body, "attempt/jan/") != null);
try std.testing.expect(std.ascii.findIgnoreCase(got.head, "x-zit-diverted") == null);
const a_after = try collectArtifactDigests(gpa, io, tmp_a.dir);
defer freeDigests(gpa, a_after);
try std.testing.expectEqual(a_before.len, a_after.len);
}
{
const got = try pushProtectedHead(gpa, io, tmp_a.dir, b_repo, a_before, project, headers);
defer gpa.free(got.head);
defer gpa.free(got.body);
try std.testing.expect(!std.mem.startsWith(u8, got.body, "error "));
try std.testing.expect(std.mem.indexOf(u8, got.body, "pragma zit-diverted ") != null);
const want = try std.fmt.allocPrint(gpa, "x-zit-diverted: {s} attempt/jan/{s} trunk", .{ grow, grow[0..12] });
defer gpa.free(want);
try std.testing.expect(std.ascii.findIgnoreCase(got.head, want) != null);
}
{
var info = try runZit(gpa, io, tmp_a.dir, &.{ "info", grow });
defer freeResult(gpa, &info);
try expectExitDiag(info.term, 0, info);
const want = try std.fmt.allocPrint(gpa, "branch: attempt/jan/{s}\n", .{grow[0..12]});
defer gpa.free(want);
try std.testing.expect(std.mem.indexOf(u8, info.stdout, want) != null);
const trunk_tip = try tipHashOf(gpa, io, tmp_a.dir, "trunk");
defer gpa.free(trunk_tip);
try std.testing.expectEqualStrings(seed, trunk_tip);
}
}
/// `pushProtected` with the front's headers spelled out, keeping the
/// response head.
fn pushProtectedHead(gpa: std.mem.Allocator, io: std.Io, served: std.Io.Dir, from: std.Io.Dir, except: []const []const u8, project: []const u8, headers: []const u8) !XferHead {
const files = try pushCardsFrom(gpa, io, from, except);
defer gpa.free(files);
const request = try std.fmt.allocPrint(gpa, "pragma client-version 20000\npush {s} {s}\n{s}", .{ repeat("c", 40), project, files });
defer gpa.free(request);
const port = try freshLoopbackPort(io);
var server = try spawnServeFronted(gpa, io, served, port, true);
defer server.kill(io);
try waitForListen(io, port);
return postXferCardsHead(gpa, io, port, request, headers);
}
/// Push everything `from` holds beyond `except` to a fronted server over
/// `served`, with trunk protected, and return the reply's cards.
fn pushProtected(gpa: std.mem.Allocator, io: std.Io, served: std.Io.Dir, from: std.Io.Dir, except: []const []const u8, project: []const u8) ![]u8 {
const files = try pushCardsFrom(gpa, io, from, except);
defer gpa.free(files);
const request = try std.fmt.allocPrint(gpa, "pragma client-version 20000\npush {s} {s}\n{s}", .{ repeat("c", 40), project, files });
defer gpa.free(request);
const port = try freshLoopbackPort(io);
var server = try spawnServeFronted(gpa, io, served, port, true);
defer server.kill(io);
try waitForListen(io, port);
return postXferCardsHeaders(gpa, io, port, request, "X-Zit-Protect: trunk\r\n");
}
test "cli serve: a box whose own signed erasure passes its not-before reclaims between connections and stops serving the bytes" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
const names = try erasureOrigin(gpa, io, tmp.dir);
defer gpa.free(names.secret);
defer gpa.free(names.other);
var a = try tmp.dir.openDir(io, "a", .{});
defer a.close(io);
// The box signs for itself, its 24 h delay ending a few seconds from now
// on the server's own wall clock.
const now = std.Io.Timestamp.now(io, .real).toSeconds();
var at_buf: [24]u8 = undefined;
const signed_at = try std.fmt.bufPrint(&at_buf, "{d}", .{now - zit.erasure.default_delay + 3});
try erasureOk(gpa, io, a, .{ .epoch = signed_at, .key = erasure_seed_hex }, &.{ "shun", "--force", "--sign", names.secret });
const port = try freshLoopbackPort(io);
var server = try spawnServe(gpa, io, a, port);
defer server.kill(io);
try waitForListen(io, port);
const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
defer gpa.free(url);
try erasureOk(gpa, io, tmp.dir, .{}, &.{ "clone", url, "early" });
var early = try tmp.dir.openDir(io, "early", .{});
defer early.close(io);
try std.testing.expect(try storeHoldsArtifact(gpa, io, early, names.secret));
// Each connection gives the server its between-connections turn.
const start = std.Io.Clock.now(.awake, io).nanoseconds;
while (try storeHoldsArtifact(gpa, io, a, names.secret)) {
if (std.Io.Clock.now(.awake, io).nanoseconds - start > 20 * std.time.ns_per_s) return error.StillHeld;
const reply = try postXferCards(gpa, io, port, "pragma client-version 20000\n");
gpa.free(reply);
io.sleep(.{ .nanoseconds = 200_000_000 }, .awake) catch {};
}
try erasureOk(gpa, io, tmp.dir, .{}, &.{ "clone", "--no-open", url, "late" });
var late = try tmp.dir.openDir(io, "late", .{});
defer late.close(io);
try std.testing.expect(!try storeHoldsArtifact(gpa, io, late, names.secret));
}