Jorijn van der Graaf
339f4b9b40
Beside the push gates, crafter-review runs the pre-send review of a kernel contributor's workbench: --mode series over a format-patch export with its cover letter, --mode reply over a mail draft. The inventory partitions a cover letter, a plain mail and the camera review's shape; ten kernel lenses join the table with their gates (structure, code, artifact truth) and the persona gate - one maintainer-persona instance per --reviewers entry, its whole pass gating its blocks and pruning the units that are not theirs. A series' code units are keyed on the code like the push gates'; every text unit on its text, the references it cites and the anchor when it is dated. The references an artifact cites are prefetched through utilities/lore.py into the gate-state, with a digest in the run layer, and a persona's calibration map is its lore listing. The kernel schema carries the persona vocabulary, the kernel note kinds, the predicted review and the not-mine list; the matrix the persona holes, the thin and the modelled units; gates clean without a persona pass is GATES CLEAN. A reply's gate-state sits beside the draft and is read once; a kernel mode needs --subsystem, defaults the effort to max and the trees to work/linux,work/milos-linux, and excuses no unit from the holes. The kernel lenses and the common text ship verbatim; the table lists them after the push gates' lenses and the config template holds them off, so a repository that never turns them on changes nothing. Prompts, keys and plans were checked byte for byte against the pipeline these modes replace, on its own artifacts: two replies and a series, every system prompt, user prompt, job and reuse key identical.
74 lines
4 KiB
C++
74 lines
4 KiB
C++
// SPDX-License-Identifier: AGPL-3.0-only
|
|
// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts®
|
|
|
|
export module Crafter.Review:State;
|
|
import std;
|
|
import :Json;
|
|
|
|
// unit-state.json (per-unit reuse), the run lock, the usage totals and the
|
|
// stdout summary. unit-state.json is merged on write, because drivers share
|
|
// one gate-state dir, and one full run per hash holds the hash's lock: every
|
|
// driver on the machine reads and writes these, so the files, the locks and
|
|
// the layout do not change.
|
|
export namespace Crafter::Review::State {
|
|
// {version: 1, entries: {}, personaPass: null}
|
|
Json EmptyState();
|
|
// The file as JSON, whatever its shape, or the empty state when it is
|
|
// missing or does not parse.
|
|
Json LoadState(const std::filesystem::path& path);
|
|
// This run's stores and drops applied to the state on disk — pure. Drops
|
|
// win over sets; an entry of `sets` that is not a whole pass gets its
|
|
// clean-read count from the FILE's previous entry (or the one-read
|
|
// synthesis of an entry stored before the count was kept) plus `read`
|
|
// unless that (hash, round) is counted already; `persona` sets
|
|
// personaPass when given. Garbage on disk is the empty state. `sets` is
|
|
// an object; a null `read` counts nothing.
|
|
Json MergeState(const Json& disk, const Json& sets, std::span<const std::string> drops = {}, const Json& read = nullptr, const Json& persona = nullptr);
|
|
// The whole state written as it is, through `<path>.tmp`.
|
|
void SaveWhole(const std::filesystem::path& path, const Json& state);
|
|
// Merge-on-write: the file re-read under `<path>.lock`, this run's deltas
|
|
// applied (MergeState), written atomically; returns the merged state. Two
|
|
// drivers on one gate-state dir would otherwise overwrite each other's
|
|
// stores, and a --no-reuse run would wipe the file from its empty object.
|
|
Json SaveState(const std::filesystem::path& path, const Json& sets, std::span<const std::string> drops = {}, const Json& read = nullptr, const Json& persona = nullptr);
|
|
|
|
// ---- one full run per hash -------------------------------------------------
|
|
// Another full run holds this hash's lock; what() names the holder.
|
|
class RunLocked : public std::runtime_error {
|
|
public:
|
|
using std::runtime_error::runtime_error;
|
|
};
|
|
std::filesystem::path LockPath(const std::filesystem::path& gateDir, std::string_view mode, std::string_view hash8);
|
|
// The holder's JSON, {} when there is none or it does not parse.
|
|
Json ReadLockInfo(const std::filesystem::path& path);
|
|
std::string Describe(const Json& info);
|
|
|
|
// An exclusive, non-blocking flock on gate-state/.run-<mode>-<hash8>.lock,
|
|
// kept for the life of the process: the kernel releases it when the
|
|
// holder dies, and no child inherits it. The file is never unlinked: an
|
|
// unlink and re-create would hand two drivers one hash.
|
|
class RunLock {
|
|
public:
|
|
// Throws RunLocked naming the holder.
|
|
RunLock(const std::filesystem::path& gateDir, std::string_view mode, std::string_view hash8);
|
|
~RunLock();
|
|
RunLock(const RunLock&) = delete;
|
|
RunLock& operator=(const RunLock&) = delete;
|
|
// The holder's identity, once it knows its run number: one JSON
|
|
// document, truncated and rewritten.
|
|
void WriteInfo(const Json& info);
|
|
|
|
private:
|
|
std::int32_t fd = -1;
|
|
};
|
|
// Who holds this hash's run lock ({} while the holder has not written
|
|
// itself yet), nullopt when nobody does: a test or dry run takes no lock
|
|
// but numbers its scratch dir past a live holder.
|
|
std::optional<Json> LockHolder(const std::filesystem::path& gateDir, std::string_view mode, std::string_view hash8);
|
|
std::int64_t NextRunNumber(const std::filesystem::path& gateDir, std::string_view mode, std::string_view hash8);
|
|
|
|
// The usage of a set of pass records, summed in the order they come.
|
|
Json UsageTotals(std::span<const Json> records);
|
|
// The stdout summary of a run's dump.
|
|
std::string Summary(const Json& dump);
|
|
}
|