Jorijn van der Graaf
741e3a656d
The modules that turn a frozen range into passes and passes into a verdict: :Schema, :Tools (the DENY, git and base lists, a leaf, so the config and the pool both read them), :Plan, :Artifact, :Inventory, :Dispositions, :State, :Normalize, :Stream, :Prompt, :Config, and the URL half of :PgWire. Units, jobs, results, the config and the claude stream stay JSON from end to end, so every key keeps its place; :Text gives JSON values truthiness, get, ==, membership and Str(), and throws Dyn::Error under a name for each kind of unexpected data. Exactness where the bytes are seen: - the stream classifiers are hand-written scanners with case-insensitive folds (the Kelvin sign is a k), Unicode \b and \s, and `.` stopping at \n; the SQL call detection takes `<exe> sql` with any path before it; - config problems carry the JSON scanner's and the UTF-8 decoder's own texts, positions included; - a float total is Neumaier's compensated sum, and the build passes -ffp-contract=off: -march=native would fuse a*b+c; - `crafter-review inventory` and `config` print what the goldens record, byte for byte (the fixture and 14 configs, broken ones included); a message names this binary as the command to run. tests/Goldens: the recorded answers over the fixtures next to them (the commits fixture, a rich versioned series with CRLF, a folded subject, Markdown headings in and out of fences, the code-key rewrites); the suite compares 2304 results as DumpFile writes them, so a key out of order fails too. All agree. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
73 lines
3.9 KiB
C++
73 lines
3.9 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. 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);
|
|
// 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);
|
|
|
|
// ---- 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);
|
|
}
|