Jorijn van der Graaf
fbb5809aea
ShouldServeOverQuic runs a Session that listens for real and reaches it with the client's own transport. It covers: - the discovery record, and its removal when the Session ends; - status, call, a mistyped command, get and set, and log --follow streaming as entries are logged and ending on time; - six clients at once, and eight streams at once on one connection; - a wrong token, a request that isn't JSON, and one over 1 MiB, each answered with an error; - ending the Session with a follower waiting, which is told "shutting down" and is not sent a backlog it asked none of; - a client finding the port dead in milliseconds. The shutdown reply went missing in 4 runs of 30 until Crafter.Network's ~ClientQUIC let stopped streams finish before closing; 50 of 50 pass since. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
238 lines
10 KiB
C++
238 lines
10 KiB
C++
// SPDX-License-Identifier: LGPL-3.0-only
|
|
// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts®
|
|
|
|
// Four configurations:
|
|
// Crafter.Debug.Core what the app and the client share (values, codecs,
|
|
// the protocol, discovery, build info)
|
|
// Crafter.Debug.Cli the client's code, a library so tests can run it
|
|
// crafter.debug-cli the client, crafter-debug
|
|
// Crafter.Debug what an app links (returned), depending on the core
|
|
// and the client
|
|
// The client is one of the library's dependencies only so that a consumer's
|
|
// debug build compiles it in the same pass as the app; an executable adds no
|
|
// link flags to what depends on it. Consumers load this file through
|
|
// Debug::Use (tooling/), which also writes their launcher.
|
|
//
|
|
// The library and the client talk QUIC through Crafter.Network, which comes
|
|
// from forgejo, with --local from the checkout beside this one, or from the
|
|
// project.cpp $CRAFTER_DEBUG_NETWORK names (a Network worktree).
|
|
import std;
|
|
import Crafter.Build;
|
|
namespace fs = std::filesystem;
|
|
using namespace Crafter;
|
|
|
|
namespace {
|
|
// The configurations this file makes besides the one it returns, at
|
|
// stable addresses for the pointers in `dependencies`. One set per load,
|
|
// not statics: a static would keep the first load's args for every load.
|
|
std::deque<Configuration> owned;
|
|
|
|
// This file's directory. A configuration a project file makes for itself
|
|
// keeps the path it is given, and "./" would later resolve against the
|
|
// consumer's directory instead of this one.
|
|
fs::path Root() {
|
|
return fs::path(std::source_location::current().file_name()).parent_path();
|
|
}
|
|
|
|
// Crafter.Network, with the args unchanged: a consumer that also uses
|
|
// it passes the same ones, so both resolve to one configuration rather
|
|
// than one module built twice.
|
|
Configuration* Network(std::span<const std::string_view> args) {
|
|
const std::vector<std::string> forwarded(args.begin(), args.end());
|
|
if (const char* local = std::getenv("CRAFTER_DEBUG_NETWORK"); local != nullptr && *local != '\0') {
|
|
return LocalProject({ .projectFile = local, .args = forwarded });
|
|
}
|
|
if (std::ranges::find(args, std::string_view("--local")) != args.end()) {
|
|
return LocalProject({ .projectFile = Root().parent_path() / "Crafter.Network" / "project.cpp", .args = forwarded });
|
|
}
|
|
return GitProject({
|
|
.source = { .url = "https://forgejo.catcrafts.net/Catcrafts/Crafter.Network.git" },
|
|
.args = forwarded,
|
|
});
|
|
}
|
|
|
|
// Tests of the core, linked against it alone.
|
|
constexpr std::array<std::string_view, 5> coreTests = {
|
|
"ShouldRoundTripJson",
|
|
"ShouldRoundTripAggregates",
|
|
"ShouldReportDecodeErrorsWithPaths",
|
|
"ShouldDescribeDefaultsAndRequired",
|
|
"ShouldDiscoverLiveInstances",
|
|
};
|
|
|
|
// Tests of the app library.
|
|
constexpr std::array<std::string_view, 7> libraryTests = {
|
|
"ShouldInvokeCommands",
|
|
"ShouldResolveWatchPaths",
|
|
"ShouldRecordTimeline",
|
|
"ShouldEvaluateConditions",
|
|
"ShouldAnswerRequests",
|
|
"ShouldPauseAndStep",
|
|
"ShouldWaitTraceAndFollow",
|
|
};
|
|
|
|
std::string ReadFile(const fs::path& path) {
|
|
std::ifstream in(path, std::ios::binary);
|
|
return std::string((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
|
|
}
|
|
|
|
// FNV-1a over the path and bytes of every source, in a fixed order: what
|
|
// the app and the client compare to tell they came from the same code.
|
|
std::string SourceId() {
|
|
std::vector<fs::path> files;
|
|
for (const std::string_view dir : { "interfaces", "implementations" }) {
|
|
std::error_code ec;
|
|
for (const fs::directory_entry& entry : fs::recursive_directory_iterator(Root() / dir, ec)) {
|
|
if (entry.is_regular_file() && (entry.path().extension() == ".cppm" || entry.path().extension() == ".cpp")) files.push_back(entry.path());
|
|
}
|
|
}
|
|
std::ranges::sort(files);
|
|
std::uint64_t hash = 14695981039346656037ULL;
|
|
const auto mix = [&](std::string_view bytes) {
|
|
for (const char c : bytes) {
|
|
hash ^= static_cast<std::uint8_t>(c);
|
|
hash *= 1099511628211ULL;
|
|
}
|
|
};
|
|
for (const fs::path& file : files) {
|
|
mix(file.lexically_relative(Root()).generic_string());
|
|
mix(ReadFile(file));
|
|
}
|
|
return std::format("{:016x}", hash);
|
|
}
|
|
|
|
void WriteIfChanged(const fs::path& file, const std::string& text) {
|
|
if (fs::exists(file) && ReadFile(file) == text) return;
|
|
fs::create_directories(file.parent_path());
|
|
std::ofstream(file, std::ios::binary | std::ios::trunc) << text;
|
|
}
|
|
|
|
// Generates the definitions of :BuildInfo for this variant of the core and
|
|
// returns the source to compile, without its extension.
|
|
fs::path GenerateBuildInfo(const Configuration& core, const Configuration& client) {
|
|
const fs::path source = Root() / "build" / "generated" / core.VariantId() / "Crafter.Debug.Core-BuildInfo";
|
|
const fs::path clientPath = client.BinDir() / client.outputName;
|
|
WriteIfChanged(fs::path(source).concat(".cpp"), std::format(
|
|
"// Generated by Crafter.Debug's project.cpp whenever the sources or the client's\n"
|
|
"// path change. Not to be edited.\n"
|
|
"module Crafter.Debug.Core:BuildInfo_impl;\n"
|
|
"import std;\n"
|
|
"import :BuildInfo;\n"
|
|
"\n"
|
|
"std::string_view Crafter::Debug::Detail::SourceId() {{\n"
|
|
" return \"{}\";\n"
|
|
"}}\n"
|
|
"\n"
|
|
"std::string_view Crafter::Debug::Detail::ClientPath() {{\n"
|
|
" return R\"crafter-debug({})crafter-debug\";\n"
|
|
"}}\n",
|
|
SourceId(), clientPath.string()));
|
|
return source;
|
|
}
|
|
}
|
|
|
|
extern "C" Configuration CrafterBuildProject(std::span<const std::string_view> args) {
|
|
Configuration cfg;
|
|
cfg.path = "./";
|
|
cfg.name = "Crafter.Debug";
|
|
cfg.outputName = "Crafter.Debug";
|
|
cfg.type = ConfigurationType::LibraryStatic;
|
|
ApplyStandardArgs(cfg, args);
|
|
|
|
Configuration* network = Network(args);
|
|
|
|
Configuration& core = owned.emplace_back();
|
|
core.path = Root();
|
|
core.name = "Crafter.Debug.Core";
|
|
core.outputName = "Crafter.Debug.Core";
|
|
core.type = ConfigurationType::LibraryStatic;
|
|
ApplyStandardArgs(core, args);
|
|
|
|
// The client, built for the library's target. Not through
|
|
// ApplyStandardArgs: a consumer's --lib would make it a library.
|
|
Configuration& client = owned.emplace_back();
|
|
client.path = Root();
|
|
client.name = "crafter.debug-cli";
|
|
client.outputName = "crafter-debug";
|
|
client.type = ConfigurationType::Executable;
|
|
client.target = cfg.target;
|
|
client.march = cfg.march;
|
|
client.mtune = cfg.mtune;
|
|
client.sysroot = cfg.sysroot;
|
|
client.debug = cfg.debug;
|
|
|
|
// The client's code as a library, so tests can run it in process.
|
|
Configuration& cli = owned.emplace_back();
|
|
cli.path = Root();
|
|
cli.name = "Crafter.Debug.Cli";
|
|
cli.outputName = "Crafter.Debug.Cli";
|
|
cli.type = ConfigurationType::LibraryStatic;
|
|
cli.target = cfg.target;
|
|
cli.march = cfg.march;
|
|
cli.mtune = cfg.mtune;
|
|
cli.sysroot = cfg.sysroot;
|
|
cli.debug = cfg.debug;
|
|
cli.dependencies = { &core, network };
|
|
client.dependencies = { &cli };
|
|
|
|
{
|
|
std::array<fs::path, 8> interfaces = {
|
|
"interfaces/Crafter.Debug.Core-Value",
|
|
"interfaces/Crafter.Debug.Core-Reflect",
|
|
"interfaces/Crafter.Debug.Core-Codec",
|
|
"interfaces/Crafter.Debug.Core-Result",
|
|
"interfaces/Crafter.Debug.Core-Protocol",
|
|
"interfaces/Crafter.Debug.Core-BuildInfo",
|
|
"interfaces/Crafter.Debug.Core-Discovery",
|
|
"interfaces/Crafter.Debug.Core",
|
|
};
|
|
std::array<fs::path, 5> implementations = {
|
|
"implementations/Crafter.Debug.Core-Value",
|
|
"implementations/Crafter.Debug.Core-Codec",
|
|
"implementations/Crafter.Debug.Core-Protocol",
|
|
"implementations/Crafter.Debug.Core-Discovery",
|
|
GenerateBuildInfo(core, client),
|
|
};
|
|
core.GetInterfacesAndImplementations(interfaces, implementations);
|
|
}
|
|
{
|
|
std::array<fs::path, 3> interfaces = { "interfaces/Crafter.Debug.Cli-Client", "interfaces/Crafter.Debug.Cli-Quic", "interfaces/Crafter.Debug.Cli" };
|
|
std::array<fs::path, 2> implementations = { "implementations/Crafter.Debug.Cli-Client", "implementations/Crafter.Debug.Cli-Quic" };
|
|
cli.GetInterfacesAndImplementations(interfaces, implementations);
|
|
}
|
|
{
|
|
std::array<fs::path, 0> interfaces = {};
|
|
std::array<fs::path, 1> implementations = { "implementations/main" };
|
|
client.GetInterfacesAndImplementations(interfaces, implementations);
|
|
}
|
|
|
|
cfg.dependencies = { &core, &client, network };
|
|
{
|
|
std::array<fs::path, 6> interfaces = {
|
|
"interfaces/Crafter.Debug-Registry",
|
|
"interfaces/Crafter.Debug-Timeline",
|
|
"interfaces/Crafter.Debug-Condition",
|
|
"interfaces/Crafter.Debug-Session",
|
|
"interfaces/Crafter.Debug-Transport",
|
|
"interfaces/Crafter.Debug",
|
|
};
|
|
std::array<fs::path, 5> implementations = {
|
|
"implementations/Crafter.Debug-Registry",
|
|
"implementations/Crafter.Debug-Timeline",
|
|
"implementations/Crafter.Debug-Condition",
|
|
"implementations/Crafter.Debug-Session",
|
|
"implementations/Crafter.Debug-Transport",
|
|
};
|
|
cfg.GetInterfacesAndImplementations(interfaces, implementations);
|
|
}
|
|
|
|
// Tests only when this is the project being built: a consumer's load of
|
|
// this file has no use for them.
|
|
if (IsTopLevelProject()) {
|
|
for (const std::string_view test : coreTests) cfg.AddTest(test).Dependencies({ &core });
|
|
for (const std::string_view test : libraryTests) cfg.AddTest(test).Dependencies({ &cfg });
|
|
cfg.AddTest("ShouldRunClientCommands").Dependencies({ &cfg, &cli });
|
|
cfg.AddTest("ShouldServeOverQuic").Dependencies({ &cfg, &cli });
|
|
}
|
|
return cfg;
|
|
}
|