#include "Resilience.hpp" #include #include #include #include #include "Http.hpp" namespace molo::example::fw { using Guard = std::lock_guard; void ManualClock::advance(long ms) { if (ms < 0) ms = 0; if (ms > labcaps::kMaxAdvanceMs) ms = labcaps::kMaxAdvanceMs; now_ += ms; } std::string fnv_hex(const std::string& data) { unsigned long long h = 1469598103934665603ULL; for (unsigned char c : data) { h ^= c; h *= 1099511628211ULL; } static const char* d = "0123456789abcdef"; std::string out(16, '0'); for (int i = 15; i >= 0; --i) { out[(std::size_t)i] = d[h & 0xF]; h >>= 4; } return out; } std::string base64_encode(const std::string& in) { static const char* t = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; std::string out; std::size_t i = 0; while (i < in.size()) { unsigned v = (unsigned char)in[i] << 16; std::size_t n = in.size() - i; if (n > 1) v |= (unsigned char)in[i + 1] << 8; if (n > 2) v |= (unsigned char)in[i + 2]; out += t[(v >> 18) & 63]; out += t[(v >> 12) & 63]; out += n > 1 ? t[(v >> 6) & 63] : '='; out += n > 2 ? t[v & 63] : '='; i += 3; } return out; } // ---- Lab ------------------------------------------------------------------- void Lab::note(std::string line) { log_.push_back(std::move(line)); while (log_.size() > labcaps::kLogLines) log_.pop_front(); } std::vector Lab::log() const { Guard g(mu_); return {log_.begin(), log_.end()}; } std::string Lab::json() const { Guard g(mu_); std::string out = "{\"name\":\"" + json_escape(name()) + "\",\"state\":{"; bool first = true; for (const auto& [k, v] : rows()) { out += std::string(first ? "" : ",") + "\"" + json_escape(k) + "\":\"" + json_escape(v) + "\""; first = false; } out += "},\"log\":["; first = true; for (const auto& l : log_) { out += std::string(first ? "" : ",") + "\"" + json_escape(l) + "\""; first = false; } return out + "]}"; } // ---- CircuitBreaker -------------------------------------------------------- std::string breaker_state_name(CircuitBreaker::State s) { switch (s) { case CircuitBreaker::State::Closed: return "closed"; case CircuitBreaker::State::Open: return "open"; case CircuitBreaker::State::HalfOpen: return "half-open"; } return "?"; } CircuitBreaker::CircuitBreaker(std::shared_ptr clock, int threshold, long open_ms) : clock_(std::move(clock)), threshold_(threshold), open_ms_(open_ms) {} CircuitBreaker::State CircuitBreaker::effective() const { if (state_ == State::Open && clock_->now() - opened_at_ >= open_ms_) return State::HalfOpen; return state_; } CircuitBreaker::State CircuitBreaker::state() const { Guard g(mu_); return effective(); } bool CircuitBreaker::call(bool success) { Guard g(mu_); State before = effective(); if (before == State::Open) { ++rejected_; note("call rejected: breaker open"); return false; } state_ = before; if (success) { failures_ = 0; state_ = State::Closed; } else if (before == State::HalfOpen || ++failures_ >= threshold_) { state_ = State::Open; opened_at_ = clock_->now(); failures_ = 0; } note(std::string(success ? "success" : "failure") + ": " + breaker_state_name(before) + " -> " + breaker_state_name(state_)); return true; } void CircuitBreaker::tick(long ms) { Guard g(mu_); State before = effective(); clock_->advance(ms); note("clock +" + std::to_string(ms) + "ms"); if (before != effective()) note(breaker_state_name(before) + " -> " + breaker_state_name(effective())); } LabRows CircuitBreaker::rows() const { Guard g(mu_); return {{"state", breaker_state_name(effective())}, {"failures", std::to_string(failures_) + "/" + std::to_string(threshold_)}, {"rejected", std::to_string(rejected_)}, {"clock_ms", std::to_string(clock_->now())}, {"reopens_after_ms", std::to_string(open_ms_)}}; } // ---- Bulkhead -------------------------------------------------------------- Bulkhead::Bulkhead(int a, int q) : max_active_(a), max_queue_(q) {} Bulkhead::Admission Bulkhead::acquire() { Guard g(mu_); if (active_ < max_active_) { ++active_; note("admitted"); return Admission::Admitted; } if (queued_ < max_queue_) { ++queued_; note("queued"); return Admission::Queued; } ++rejected_; note("rejected: compartment full"); return Admission::Rejected; } bool Bulkhead::release() { Guard g(mu_); if (active_ == 0) return false; if (queued_ > 0) { --queued_; note("released, queued call promoted"); } else { --active_; note("released"); } return true; } LabRows Bulkhead::rows() const { Guard g(mu_); return {{"active", std::to_string(active_) + "/" + std::to_string(max_active_)}, {"queued", std::to_string(queued_) + "/" + std::to_string(max_queue_)}, {"rejected", std::to_string(rejected_)}}; } // ---- Shedder --------------------------------------------------------------- bool Shedder::enter(bool high) { Guard g(mu_); int cap = high ? limit_ : limit_ * 2 / 3; if (inflight_ >= cap) { (high ? shed_high_ : shed_low_)++; note(std::string("shed ") + (high ? "high" : "low") + " priority"); return false; } ++inflight_; note(std::string("accepted ") + (high ? "high" : "low") + " priority"); return true; } bool Shedder::leave() { Guard g(mu_); if (inflight_ == 0) return false; --inflight_; note("finished"); return true; } LabRows Shedder::rows() const { Guard g(mu_); return {{"inflight", std::to_string(inflight_) + "/" + std::to_string(limit_)}, {"low_priority_cutoff", std::to_string(limit_ * 2 / 3)}, {"shed_low", std::to_string(shed_low_)}, {"shed_high", std::to_string(shed_high_)}}; } // ---- Deadline -------------------------------------------------------------- int DeadlineLab::run(long budget_ms, int hops) { Guard g(mu_); budget_ms_ = budget_ms; remaining_ms_ = budget_ms; hops_ = hops; expired_hop_ = 0; ran_ = true; for (int h = 1; h <= hops; ++h) { if (remaining_ms_ < kHopCostMs) { expired_hop_ = h; note("hop " + std::to_string(h) + ": deadline exceeded, call skipped"); break; } remaining_ms_ -= kHopCostMs; note("hop " + std::to_string(h) + ": ok, " + std::to_string(remaining_ms_) + "ms left"); } return expired_hop_; } LabRows DeadlineLab::rows() const { Guard g(mu_); if (!ran_) return {{"status", "not run"}, {"hop_cost_ms", "30"}}; return {{"status", expired_hop_ ? "expired" : "completed"}, {"budget_ms", std::to_string(budget_ms_)}, {"hops", std::to_string(hops_)}, {"expired_at_hop", std::to_string(expired_hop_)}, {"remaining_ms", std::to_string(remaining_ms_)}, {"hop_cost_ms", "30"}}; } // ---- SloBudget ------------------------------------------------------------- void SloBudget::record(bool good) { Guard g(mu_); window_.push_back(good); if (window_.size() > kWindow) window_.pop_front(); note(good ? "good event" : "bad event"); } void SloBudget::reset() { Guard g(mu_); window_.clear(); note("window reset"); } long SloBudget::budget_remaining() const { Guard g(mu_); long bad = std::count(window_.begin(), window_.end(), false); long allowed = (long)window_.size() * (1000 - target_) / 1000; return allowed - bad; } LabRows SloBudget::rows() const { Guard g(mu_); long bad = std::count(window_.begin(), window_.end(), false); long left = budget_remaining(); return {{"target", std::to_string(target_ / 10) + "." + std::to_string(target_ % 10) + "%"}, {"events", std::to_string(window_.size()) + "/" + std::to_string(kWindow)}, {"bad", std::to_string(bad)}, {"budget_remaining", std::to_string(left)}, {"state", bad == 0 ? "healthy" : left >= 0 ? "burning" : "exhausted"}}; } // ---- ChaosLab -------------------------------------------------------------- ChaosLab::Result ChaosLab::run(int percent, int max_faults, bool armed) { Guard g(mu_); percent = std::clamp(percent, 0, labcaps::kMaxPercent); max_faults = std::clamp(max_faults, 1, labcaps::kMaxFaults); Result r; r.percent = percent; r.max_faults = max_faults; r.armed = armed; int acc = 0; for (int i = 0; i < kCalls && r.planned < max_faults; ++i) { acc += percent; if (acc >= 100) { acc -= 100; ++r.planned; } } r.injected = armed ? r.planned : 0; last_ = r; ++runs_; total_injected_ += r.injected; note(std::string(armed ? "ARMED" : "dry run") + ": " + std::to_string(r.planned) + " fault(s) planned over " + std::to_string(kCalls) + " calls, " + std::to_string(r.injected) + " injected"); return r; } LabRows ChaosLab::rows() const { Guard g(mu_); return {{"mode", last_.armed ? "armed" : "dry run"}, {"percent", std::to_string(last_.percent) + " (cap " + std::to_string(labcaps::kMaxPercent) + ")"}, {"max_faults", std::to_string(last_.max_faults) + " (cap " + std::to_string(labcaps::kMaxFaults) + ")"}, {"planned", std::to_string(last_.planned)}, {"injected", std::to_string(last_.injected)}, {"runs", std::to_string(runs_)}, {"total_injected", std::to_string(total_injected_)}}; } // ---- DeployLab ------------------------------------------------------------- std::string deploy_phase_name(DeployLab::Phase p) { switch (p) { case DeployLab::Phase::Idle: return "idle"; case DeployLab::Phase::InProgress: return "in progress"; case DeployLab::Phase::Done: return "done"; case DeployLab::Phase::RolledBack: return "rolled back"; } return "?"; } DeployLab::DeployLab() : fleet_(4, "v1") {} DeployLab::Phase DeployLab::phase() const { Guard g(mu_); return phase_; } bool DeployLab::start(const std::string& strategy, const std::string& version) { Guard g(mu_); if (phase_ == Phase::InProgress) return false; previous_ = fleet_; strategy_ = strategy; target_ = version; green_stage_ = 0; phase_ = Phase::InProgress; note("start " + strategy + " to " + version); return true; } bool DeployLab::step() { Guard g(mu_); if (phase_ != Phase::InProgress) return false; if (strategy_ == "rolling") { for (auto& v : fleet_) { if (v != target_) { v = target_; note("replaced one instance with " + target_); break; } } if (std::all_of(fleet_.begin(), fleet_.end(), [&](const std::string& v) { return v == target_; })) { phase_ = Phase::Done; note("rolling finished"); } } else if (green_stage_ == 0) { green_stage_ = 1; note("green fleet " + target_ + " prepared, blue still serves"); } else { std::fill(fleet_.begin(), fleet_.end(), target_); phase_ = Phase::Done; note("traffic switched to green"); } return true; } bool DeployLab::rollback() { Guard g(mu_); if (phase_ == Phase::Idle || phase_ == Phase::RolledBack) return false; fleet_ = previous_; phase_ = Phase::RolledBack; note("rolled back to previous fleet"); return true; } LabRows DeployLab::rows() const { Guard g(mu_); std::string fleet; for (const auto& v : fleet_) fleet += (fleet.empty() ? "" : ",") + v; return {{"strategy", strategy_}, {"phase", deploy_phase_name(phase_)}, {"target", target_.empty() ? "-" : target_}, {"fleet", fleet}}; } // ---- CoordLab -------------------------------------------------------------- CoordLab::CoordLab(std::shared_ptr clock, long ttl_ms) : clock_(std::move(clock)), ttl_ms_(ttl_ms) {} bool CoordLab::known_key(const std::string& key) { return key == "lease" || key == "lock" || key == "leader"; } CoordLab::Grant CoordLab::acquire(const std::string& key, const std::string& owner) { Guard g(mu_); Slot& s = slots_[key]; bool live = !s.holder.empty() && s.expires > clock_->now(); if (live && s.holder != owner) { note(owner + " denied " + key + ": held by " + s.holder); return {false, s.token, s.holder}; } if (!live) ++s.token; // new term, new fencing token s.holder = owner; s.expires = clock_->now() + ttl_ms_; note(owner + (live ? " renewed " : " acquired ") + key + " token " + std::to_string(s.token)); return {true, s.token, owner}; } bool CoordLab::release(const std::string& key, const std::string& owner) { Guard g(mu_); auto it = slots_.find(key); if (it == slots_.end() || it->second.holder != owner) return false; it->second.holder.clear(); note(owner + " released " + key); return true; } bool CoordLab::write(const std::string& key, long token) { Guard g(mu_); Slot& s = slots_[key]; if (token < s.fence) { note("write with stale token " + std::to_string(token) + " rejected (fence " + std::to_string(s.fence) + ")"); return false; } s.fence = token; note("write with token " + std::to_string(token) + " accepted"); return true; } void CoordLab::tick(long ms) { Guard g(mu_); clock_->advance(ms); note("clock +" + std::to_string(ms) + "ms"); } LabRows CoordLab::rows() const { Guard g(mu_); LabRows out{{"clock_ms", std::to_string(clock_->now())}, {"ttl_ms", std::to_string(ttl_ms_)}}; for (const char* key : {"lease", "lock", "leader"}) { auto it = slots_.find(key); if (it == slots_.end()) { out.emplace_back(key, "free"); continue; } const Slot& s = it->second; bool live = !s.holder.empty() && s.expires > clock_->now(); out.emplace_back(key, (live ? "held by " + s.holder : std::string("free")) + ", token " + std::to_string(s.token) + ", fence " + std::to_string(s.fence)); } return out; } // ---- DebugRegistry --------------------------------------------------------- void DebugRegistry::add(std::shared_ptr lab) { labs_.push_back(std::move(lab)); } std::string DebugRegistry::snapshot() const { std::string out = "{\"count\":" + std::to_string(labs_.size()) + ",\"labs\":{"; bool first = true; for (const auto& l : labs_) { out += std::string(first ? "" : ",") + "\"" + json_escape(l->name()) + "\":" + l->json(); first = false; } return out + "}}"; } // ---- SupplyChainLab -------------------------------------------------------- SupplyChainLab::SupplyChainLab() { reset(); } void SupplyChainLab::reset() { Guard g(mu_); components_ = {{"molo-example", "1.0.0", "proprietary"}, {"chartjs", "4.4.1", "MIT"}, {"wolfssl", "5.7.2", "GPL-2.0"}, {"sqlite", "3.45.1", "blessing"}}; pins_.clear(); for (const auto& c : components_) pins_[c.name] = c.version; advisories_.clear(); attested_ = digest(); verified_ = 0; note("sbom regenerated and attested " + attested_); } std::string SupplyChainLab::digest() const { std::string canon; for (const auto& c : components_) canon += c.name + "@" + c.version + ";" + c.license + "\n"; return fnv_hex(canon); } bool SupplyChainLab::add_advisory(const std::string& component, const std::string& version) { Guard g(mu_); if (advisories_.size() >= labcaps::kMaxAdvisories) return false; advisories_.emplace_back(component, version); note("advisory published for " + component + "@" + version); return true; } void SupplyChainLab::tamper() { Guard g(mu_); components_[1].version = "4.4.2"; verified_ = 0; note("chartjs changed to 4.4.2 after attestation"); } bool SupplyChainLab::verify(const std::string& claimed) { Guard g(mu_); bool ok = claimed == attested_ && claimed == digest(); verified_ = ok ? 1 : -1; note(std::string("verify ") + (ok ? "ok" : "FAILED")); return ok; } bool SupplyChainLab::pins_ok() const { for (const auto& c : components_) { auto it = pins_.find(c.name); if (it == pins_.end() || it->second != c.version) return false; } return true; } bool SupplyChainLab::advisories_ok() const { for (const auto& c : components_) for (const auto& a : advisories_) if (a.first == c.name && a.second == c.version) return false; return true; } bool SupplyChainLab::gate() const { Guard g(mu_); return pins_ok() && advisories_ok() && attested_ == digest(); } std::string SupplyChainLab::cyclonedx() const { Guard g(mu_); std::string out = "{\"bomFormat\":\"CycloneDX\",\"specVersion\":\"1.5\",\"components\":["; bool first = true; for (const auto& c : components_) { out += std::string(first ? "" : ",") + "{\"name\":\"" + json_escape(c.name) + "\",\"version\":\"" + json_escape(c.version) + "\",\"license\":\"" + json_escape(c.license) + "\"}"; first = false; } return out + "],\"digest\":\"" + digest() + "\"}"; } LabRows SupplyChainLab::rows() const { Guard g(mu_); LabRows out; for (const auto& c : components_) out.emplace_back(c.name, c.version + " (" + c.license + ")"); out.emplace_back("pins", pins_ok() ? "pass" : "FAIL"); out.emplace_back("advisories", advisories_ok() ? "pass (" + std::to_string(advisories_.size()) + " known)" : "FAIL"); out.emplace_back("attestation", attested_ == digest() ? "pass" : "FAIL"); out.emplace_back("last_verify", verified_ == 0 ? "none" : verified_ > 0 ? "ok" : "failed"); out.emplace_back("sbom_digest", digest()); out.emplace_back("gate", pins_ok() && advisories_ok() && attested_ == digest() ? "PASS" : "FAIL"); return out; } // ---- ClientRetryLab -------------------------------------------------------- ClientRetryLab::Outcome ClientRetryLab::run(int failures, int max_attempts, int status) { Guard g(mu_); max_attempts = std::clamp(max_attempts, 1, labcaps::kMaxAttempts); Outcome o; for (int a = 1; a <= max_attempts; ++a) { o.attempts = a; o.status = a <= failures ? status : 200; note("attempt " + std::to_string(a) + " -> " + std::to_string(o.status)); if (o.status == 200) break; if (o.status < 500) { o.gave_up = true; note("4xx is never retried"); break; } if (a == max_attempts) { o.gave_up = true; note("attempts exhausted"); break; } long wait = std::min(kCapMs, kBaseMs << (a - 1)); o.waited_ms += wait; note("backoff " + std::to_string(wait) + "ms (cap " + std::to_string(kCapMs) + "ms)"); } last_ = o; ++runs_; return o; } LabRows ClientRetryLab::rows() const { Guard g(mu_); return {{"runs", std::to_string(runs_)}, {"attempts", std::to_string(last_.attempts)}, {"final_status", std::to_string(last_.status)}, {"virtual_wait_ms", std::to_string(last_.waited_ms)}, {"gave_up", last_.gave_up ? "yes" : "no"}, {"backoff", "100ms doubling, cap 800ms"}}; } // ---- ClientSessionLab ------------------------------------------------------ ClientSessionLab::ClientSessionLab() = default; bool ClientSessionLab::valid_proxy(const std::string& p) { if (p.empty() || p == "direct") return true; for (const char* scheme : {"http://", "https://", "socks5://"}) { std::string s = scheme; if (p.compare(0, s.size(), s) != 0) continue; std::string hp = p.substr(s.size()); std::size_t colon = hp.rfind(':'); if (colon == std::string::npos || colon == 0 || colon + 1 >= hp.size()) return false; for (std::size_t i = colon + 1; i < hp.size(); ++i) if (hp[i] < '0' || hp[i] > '9') return false; return hp.size() - colon - 1 <= 5; } return false; } std::map ClientSessionLab::request( const std::string& auth, const std::string& proxy) { Guard g(mu_); std::string px = proxy.empty() ? "direct" : proxy; std::map h{{"Host", "example.internal"}}; if (!jar_.empty()) { std::string c; for (const auto& [k, v] : jar_) c += (c.empty() ? "" : "; ") + k + "=" + v; h["Cookie"] = c; } if (auth == "basic") h["Authorization"] = "Basic " + base64_encode("demo:demo"); else if (auth == "bearer") h["Authorization"] = "Bearer demo-token"; if (px != proxy_) idle_ = 0; // a new route needs a new connection proxy_ = px; auth_ = auth; if (idle_ > 0) { --idle_; ++reused_; note("connection reused"); } else { ++created_; note("connection created via " + px); } ++idle_; ++requests_; jar_["sid"] = "s-1"; // Set-Cookie from the in-process server jar_["visits"] = std::to_string(requests_); note("request " + std::to_string(requests_) + " auth=" + auth); return h; } LabRows ClientSessionLab::rows() const { Guard g(mu_); std::string jar; for (const auto& [k, v] : jar_) jar += (jar.empty() ? "" : "; ") + k + "=" + v; return {{"requests", std::to_string(requests_)}, {"cookie_jar", jar.empty() ? "empty" : jar}, {"pool_created", std::to_string(created_)}, {"pool_reused", std::to_string(reused_)}, {"pool_idle", std::to_string(idle_)}, {"proxy", proxy_}, {"auth_scheme", auth_}}; } // ---- MigrationLab ---------------------------------------------------------- MigrationLab::MigrationLab() { steps_ = {{"001", "CREATE TABLE users (id, name)", "users"}, {"002", "ALTER TABLE users ADD COLUMN email", "users"}, {"003", "CREATE TABLE posts (id, user_id, title)", "posts"}}; } std::vector MigrationLab::check() const { Guard g(mu_); std::vector out; for (const auto& s : steps_) if (std::find(applied_.begin(), applied_.end(), s.id) == applied_.end()) out.push_back(s.id + " " + s.sql); return out; } int MigrationLab::apply(int limit) { Guard g(mu_); int n = 0; for (const auto& s : steps_) { if (n >= limit) break; if (std::find(applied_.begin(), applied_.end(), s.id) != applied_.end()) continue; if (s.sql.compare(0, 6, "CREATE") == 0) tables_[s.table] = s.sql.substr(s.sql.find('(') + 1); else tables_[s.table] += " +email"; applied_.push_back(s.id); note("applied " + s.id); ++n; } return n; } void MigrationLab::drop_table(const std::string& table) { Guard g(mu_); if (tables_.erase(table)) note("table " + table + " dropped out of band"); } std::vector MigrationLab::drift() const { Guard g(mu_); std::vector out; for (const auto& s : steps_) if (s.sql.compare(0, 6, "CREATE") == 0 && !tables_.count(s.table) && std::find(applied_.begin(), applied_.end(), s.id) != applied_.end()) out.push_back(s.id + " " + s.table); return out; } int MigrationLab::heal() { Guard g(mu_); int n = 0; for (const auto& s : steps_) { if (s.sql.compare(0, 6, "CREATE") == 0 && !tables_.count(s.table) && std::find(applied_.begin(), applied_.end(), s.id) != applied_.end()) { tables_[s.table] = s.sql.substr(s.sql.find('(') + 1); note("healed " + s.table); ++n; } } return n; } LabRows MigrationLab::rows() const { Guard g(mu_); LabRows out; std::string pending, applied; for (const auto& s : steps_) { bool done = std::find(applied_.begin(), applied_.end(), s.id) != applied_.end(); (done ? applied : pending) += (done ? applied : pending).empty() ? s.id : "," + s.id; } out.emplace_back("applied", applied.empty() ? "none" : applied); out.emplace_back("pending", pending.empty() ? "none" : pending); for (const auto& [t, cols] : tables_) out.emplace_back("table " + t, cols); auto d = drift(); out.emplace_back("drift", d.empty() ? "none" : d.front()); return out; } // ---- TxLab ----------------------------------------------------------------- TxLab::TxLab() : accounts_{{"alice", 100}, {"bob", 50}} {} long TxLab::balance(const std::string& who) const { Guard g(mu_); auto it = accounts_.find(who); return it == accounts_.end() ? -1 : it->second; } std::string TxLab::transfer(const std::string& from, const std::string& to, long amount, bool fail_after_debit) { Guard g(mu_); auto snapshot = accounts_; // BEGIN accounts_[from] -= amount; std::string reason; if (accounts_[from] < 0) reason = "insufficient funds"; else if (fail_after_debit) reason = "failure after debit"; if (!reason.empty()) { accounts_ = snapshot; // ROLLBACK ++rollbacks_; note("ROLLBACK: " + reason); return "rolled back: " + reason; } accounts_[to] += amount; // COMMIT ++commits_; note("COMMIT: " + from + " -> " + to + " " + std::to_string(amount)); return "committed"; } LabRows TxLab::rows() const { Guard g(mu_); LabRows out; for (const auto& [k, v] : accounts_) out.emplace_back(k, std::to_string(v)); out.emplace_back("commits", std::to_string(commits_)); out.emplace_back("rollbacks", std::to_string(rollbacks_)); return out; } // ---- QueryLab -------------------------------------------------------------- QueryLab::QueryLab() { users_ = {{{"id", "1"}, {"name", "ada"}}, {{"id", "2"}, {"name", "grace"}}}; posts_ = {{{"id", "1"}, {"user_id", "1"}, {"title", "Alpha"}}, {{"id", "2"}, {"user_id", "1"}, {"title", "Gamma"}}, {{"id", "3"}, {"user_id", "2"}, {"title", "Beta"}}, {{"id", "4"}, {"user_id", "2"}, {"title", "Delta"}}, {{"id", "5"}, {"user_id", "1"}, {"title", "Epsilon"}}}; } QueryLab::Result QueryLab::run(long user_id, const std::string& order, int limit) { Guard g(mu_); Result r; r.sql = "SELECT posts.id, posts.title, users.name FROM posts JOIN users ON " "users.id = posts.user_id"; if (user_id > 0) r.sql += " WHERE posts.user_id = " + std::to_string(user_id); std::string col = order == "title" ? "title" : "id"; r.sql += " ORDER BY posts." + col + " LIMIT " + std::to_string(limit); std::vector> picked; for (const auto& p : posts_) { if (user_id > 0 && p.at("user_id") != std::to_string(user_id)) continue; auto row = p; for (const auto& u : users_) if (u.at("id") == p.at("user_id")) row["author"] = u.at("name"); picked.push_back(row); } std::stable_sort(picked.begin(), picked.end(), [&](const auto& a, const auto& b) { if (col == "id") return std::stol(a.at("id")) < std::stol(b.at("id")); return a.at(col) < b.at(col); }); if ((int)picked.size() > limit) picked.resize((std::size_t)limit); r.rows = std::move(picked); last_ = r; note(std::to_string(r.rows.size()) + " row(s)"); return r; } LabRows QueryLab::rows() const { Guard g(mu_); LabRows out{{"sql", last_.sql.empty() ? "not run" : last_.sql}}; for (const auto& r : last_.rows) out.emplace_back("post " + r.at("id"), r.at("title") + " by " + r.at("author")); return out; } // ---- SingleFlight ---------------------------------------------------------- std::string SingleFlight::run(const std::string& key, const std::function& loader) { std::unique_lock lk(mu_); auto it = calls_.find(key); if (it != calls_.end()) { auto call = it->second; ++call->waiters; cv_.wait(lk, [&] { return call->done; }); return call->value; } auto call = std::make_shared(); calls_[key] = call; lk.unlock(); std::string value = loader(); lk.lock(); call->value = value; call->done = true; calls_.erase(key); cv_.notify_all(); return value; } int SingleFlight::waiters(const std::string& key) const { std::lock_guard lk(mu_); auto it = calls_.find(key); return it == calls_.end() ? 0 : it->second->waiters; } SingleFlightLab::SingleFlightLab() : flight_(std::make_unique()) {} int SingleFlightLab::run(int callers) { callers = std::clamp(callers, 1, labcaps::kMaxThreads); std::atomic loads{0}; SingleFlight* flight = flight_.get(); auto loader = [&]() { ++loads; // Hold the load open until every other caller has joined (2 s cap), so // the collapse is deterministic and never depends on scheduling luck. for (int i = 0; i < 2000 && flight->waiters("report") < callers - 1; ++i) std::this_thread::sleep_for(std::chrono::milliseconds(1)); return std::string("loaded"); }; std::vector pool; for (int i = 0; i < callers; ++i) pool.emplace_back([&] { flight->run("report", loader); }); for (auto& t : pool) t.join(); Guard g(mu_); callers_ = callers; loads_ = loads.load(); ++runs_; note(std::to_string(callers) + " concurrent callers -> " + std::to_string(loads_) + " load(s)"); return loads_; } LabRows SingleFlightLab::rows() const { Guard g(mu_); return {{"runs", std::to_string(runs_)}, {"callers", std::to_string(callers_)}, {"loader_executions", std::to_string(loads_)}, {"thread_cap", std::to_string(labcaps::kMaxThreads)}}; } // ---- TtlLab ---------------------------------------------------------------- TtlLab::TtlLab(std::shared_ptr clock) : clock_(std::move(clock)) {} void TtlLab::publish(const std::string& event) { events_.push_back(event); while (events_.size() > labcaps::kLogLines) events_.pop_front(); note("kv.events: " + event); } void TtlLab::sweep() { for (auto it = entries_.begin(); it != entries_.end();) { if (it->second.expires <= clock_->now()) { publish("expired " + it->first); it = entries_.erase(it); } else { ++it; } } } void TtlLab::set(const std::string& key, const std::string& value, long ttl_s) { Guard g(mu_); sweep(); if (!entries_.count(key) && entries_.size() >= labcaps::kMaxEntries) { auto lru = std::min_element( entries_.begin(), entries_.end(), [](const auto& a, const auto& b) { return a.second.touched < b.second.touched; }); publish("evicted " + lru->first + " (lru)"); entries_.erase(lru); } entries_[key] = {value, clock_->now() + ttl_s * 1000, seq_++}; publish("set " + key); } bool TtlLab::get(const std::string& key, std::string& value) { Guard g(mu_); sweep(); auto it = entries_.find(key); if (it == entries_.end()) { ++misses_; note("miss " + key); return false; } it->second.touched = seq_++; value = it->second.value; ++hits_; note("hit " + key); return true; } void TtlLab::tick(long ms) { Guard g(mu_); clock_->advance(ms); note("clock +" + std::to_string(ms) + "ms"); sweep(); } std::size_t TtlLab::size() const { Guard g(mu_); return entries_.size(); } std::vector TtlLab::events() const { Guard g(mu_); return {events_.begin(), events_.end()}; } LabRows TtlLab::rows() const { Guard g(mu_); LabRows out{{"clock_ms", std::to_string(clock_->now())}, {"entries", std::to_string(entries_.size()) + "/" + std::to_string(labcaps::kMaxEntries)}, {"hits", std::to_string(hits_)}, {"misses", std::to_string(misses_)}}; for (const auto& [k, e] : entries_) out.emplace_back("key " + k, e.value + ", " + std::to_string((e.expires - clock_->now()) / 1000) + "s left"); return out; } } // namespace molo::example::fw