// MANIFEST encoding and atomic publish under injected faults (built with // STRAWBERRY_FAULT_INJECTION=1). A failure prints the seed; re-run with // STRAWBERRY_PROPERTY_SEED= to reproduce. // // M1 a crash at any I/O step of publish leaves exactly the old or the new // generation loadable (never neither, never a mix); a publish that // returned true always loads as the new one. // M2 encode/decode round-trips; truncation, splicing and unsafe file names // are rejected. // M3 an unreadable manifest is reported as an I/O error, never as "absent". #include "strawberry/store/manifest.hpp" #include "strawberry/sys_io.hpp" #include #include #include #include #include #include #include using namespace strawberry; using namespace strawberry::store; namespace fs = std::filesystem; namespace { uint64_t seed_from_env() { if (const char* text = std::getenv("STRAWBERRY_PROPERTY_SEED")) { return std::strtoull(text, nullptr, 10); } return std::random_device{}(); } const uint64_t kSeed = seed_from_env(); #define PROPERTY(cond) \ do { \ if (!(cond)) { \ std::cerr << "PROPERTY FAILED: " #cond " (seed " << kSeed << ", " << __FILE__ << ":" \ << __LINE__ << ")" << std::endl; \ std::abort(); \ } \ } while (0) /// Fails every I/O operation from the k-th on (a crash at step k), except /// close, which the seam never fails. class CrashAt final : public io::FaultInjector { public: explicit CrashAt(uint64_t k, int error) : k_(k), error_(error) {} io::FaultDecision decide(io::Op) noexcept override { io::FaultDecision d; if (count_++ >= k_) d.error = error_; return d; } uint64_t count() const noexcept { return count_; } private: uint64_t k_; int error_; uint64_t count_ = 0; }; class FailReads final : public io::FaultInjector { public: io::FaultDecision decide(io::Op op) noexcept override { io::FaultDecision d; if (op == io::Op::read) d.error = EIO; return d; } }; Manifest random_manifest(std::mt19937_64& rng, uint64_t generation) { Manifest m; m.generation = generation; m.created_unix_ns = rng(); m.next_segment_id = 1 + rng() % 100000; const std::size_t n = rng() % 4 == 0 ? rng() % 3000 : rng() % 20; // sometimes multi-block for (std::size_t i = 0; i < n; ++i) { ManifestSegment s; s.stream = rng() % 2 ? Stream::evidence : Stream::telemetry; s.id = 1 + rng() % 1000000; s.file = segment_file_name(s.id); s.sealed = rng() % 2; s.sealed_unix_ns = s.sealed ? rng() : 0; s.bytes = rng() % (1ull << 34); s.records = rng() % 1000000; s.min_ts = rng() % 3 == 0 ? kNoTimestamp : static_cast(rng() >> 1); s.max_ts = s.min_ts == kNoTimestamp ? kNoTimestamp : s.min_ts + static_cast(rng() % 1000); s.dictionary_id = static_cast(rng() % 3); m.segments.push_back(s); } for (std::size_t i = 0, d = rng() % 4; i < d; ++i) { ManifestDictionary dict; dict.id = 1 + static_cast(rng() % 100000); dict.stream = rng() % 2 ? Stream::evidence : Stream::telemetry; dict.file = dictionary_file_name(dict.id); m.dictionaries.push_back(dict); } return m; } struct TempDir { fs::path path; TempDir() { path = fs::temp_directory_path() / ("sb-manifest-test-" + std::to_string(::getpid())); fs::remove_all(path); fs::create_directories(path); } ~TempDir() { std::error_code ec; fs::remove_all(path, ec); } }; uint64_t g_boundary_cuts = 0, g_crash_points = 0, g_loaded_new = 0, g_loaded_old = 0, g_from_temp = 0, g_from_prev = 0; void property_crash_atomicity(std::mt19937_64& rng, const TempDir& dir) { // M1 const std::string d = dir.path.string(); fs::remove_all(dir.path); fs::create_directories(dir.path); const uint64_t old_gen = 1 + rng() % 1000; const Manifest old_m = random_manifest(rng, old_gen); std::string error; const bool have_old = rng() % 8 != 0; // sometimes the very first publish if (have_old) PROPERTY(publish_manifest(d, old_m, error)); const Manifest new_m = random_manifest(rng, old_gen + 1); // Count the operations of a clean publish, then crash at each step. uint64_t total_ops = 0; { const fs::path probe = dir.path / "probe"; fs::create_directories(probe); if (have_old) PROPERTY(publish_manifest(probe.string(), old_m, error)); CrashAt never(UINT64_MAX, 0); io::ScopedInjector scope(&never); PROPERTY(publish_manifest(probe.string(), new_m, error)); total_ops = never.count(); fs::remove_all(probe); } const uint64_t k = rng() % (total_ops + 1); bool ok = false; { static constexpr int errors[] = {EIO, ENOSPC, EINTR}; CrashAt crash(k, errors[rng() % 3]); io::ScopedInjector scope(&crash); ok = publish_manifest(d, new_m, error); } ++g_crash_points; const ManifestLoad load = load_manifest(d); PROPERTY(load.io_error.empty()); if (ok) { PROPERTY(load.manifest == new_m); } if (!have_old) { // First publish: either nothing yet or the new manifest. PROPERTY(load.source == ManifestSource::none || load.manifest == new_m); } else { PROPERTY(load.source != ManifestSource::none); PROPERTY(load.manifest == old_m || load.manifest == new_m); } if (load.source != ManifestSource::none) { (load.manifest == new_m ? g_loaded_new : g_loaded_old)++; if (load.source == ManifestSource::temp) ++g_from_temp; if (load.source == ManifestSource::previous) ++g_from_prev; } // The next publish after a crash (generation bumped past what loaded) // succeeds and wins. Manifest next = random_manifest(rng, std::max(old_gen, load.manifest.generation) + 1); PROPERTY(publish_manifest(d, next, error)); PROPERTY(load_manifest(d).manifest == next); } void property_encoding(std::mt19937_64& rng) { // M2 for (int i = 0; i < 200; ++i) { Manifest m = random_manifest(rng, rng()); if (i % 10 == 0) { // force multi-block manifests while (m.segments.size() < 3000) { ManifestSegment s; s.id = m.segments.size() + 1; s.file = segment_file_name(s.id); m.segments.push_back(s); } } const std::string bytes = encode_manifest(m); Manifest back; PROPERTY(decode_manifest(bytes, back) && back == m); // Any truncation is rejected. PROPERTY(!decode_manifest(std::string_view(bytes).substr(0, rng() % bytes.size()), back)); // Truncation exactly at a block boundary (only the counts catch it). for (std::size_t off = kManifestHeaderBytes; off < bytes.size();) { BlockInfo info; std::size_t total = 0; PROPERTY(peek_block(std::string_view(bytes).substr(off), info, total) == BlockError::ok); off += total; if (off < bytes.size()) { ++g_boundary_cuts; PROPERTY(!decode_manifest(std::string_view(bytes).substr(0, off), back)); } } // Splicing two manifests (header of one, blocks of another) is rejected. const Manifest other = random_manifest(rng, m.generation + 1); std::string spliced = encode_manifest(other).substr(0, kManifestHeaderBytes) + bytes.substr(kManifestHeaderBytes); PROPERTY(!decode_manifest(spliced, back)); } for (const char* bad : {"../seg-1.log", "seg-1.log/..", "seg-01.log", "seg-0.log", "seg-.log", "seg-1.logx", "/etc/passwd", "dict-0.zdict", "dict-4294967296.zdict", "seg-1 .log", "seg--1.log"}) { PROPERTY(!valid_store_file_name(bad)); Manifest m; m.generation = 3; ManifestSegment s; s.id = 1; s.file = bad; m.segments.push_back(s); Manifest back; PROPERTY(!decode_manifest(encode_manifest(m), back)); } PROPERTY(valid_store_file_name("seg-1.log") && valid_store_file_name("dict-7.zdict")); // A segment whose file name disagrees with its id is rejected. Manifest m; m.generation = 1; ManifestSegment s; s.id = 2; s.file = "seg-3.log"; m.segments.push_back(s); Manifest back; PROPERTY(!decode_manifest(encode_manifest(m), back)); } void property_unreadable(std::mt19937_64& rng, const TempDir& dir) { // M3 const std::string d = dir.path.string(); std::string error; PROPERTY(publish_manifest(d, random_manifest(rng, 50), error)); FailReads fail; io::ScopedInjector scope(&fail); const ManifestLoad load = load_manifest(d); PROPERTY(!load.io_error.empty() && load.source == ManifestSource::none); } } // namespace int main(int argc, char** argv) { const int iterations = argc > 1 ? std::atoi(argv[1]) : 300; std::cout << "store manifest properties, seed " << kSeed << std::endl; std::mt19937_64 rng(kSeed); TempDir dir; property_encoding(rng); for (int i = 0; i < iterations; ++i) property_crash_atomicity(rng, dir); property_unreadable(rng, dir); std::cout << "store manifest: all properties hold (crash points " << g_crash_points << ", loaded new/old " << g_loaded_new << "/" << g_loaded_old << ", block-boundary cuts " << g_boundary_cuts << ", from temp " << g_from_temp << ", from prev " << g_from_prev << ")" << std::endl; return 0; }