#include "App.hpp" #include #include "../fw/Resilience.hpp" #include "../fw/Router.hpp" #include "../fw/Templates.hpp" #include "../fw/Validate.hpp" #include "FormUi.hpp" // Interactive lab pages for operability, supply chain, clients and data depth. // Each page is a LabPage: a GET that renders the lab state plus one POST route // per button. HTML clients get the page back, JSON clients get the lab state; // validation failures render the shared inline-error form (422). namespace molo::example::app { namespace { using Params = std::map; const char kLabPage[] = R"LAB({% extends "base.html" %} {% block content %}

{{ title }}

{{ intro }}

{% if notice %}

{{ notice }}

{% endif %}
{% for r in rows %} {% endfor %}
StateValue
{{ r.k }}{{ r.v }}
{% for a in actions %} {{ a.html|safe }} {% endfor %}

Log

{% endblock %} )LAB"; // Throws the standard field error when `value` is not one of `allowed`. void require_in(const std::string& field, const std::string& value, const std::vector& allowed) { if (std::find(allowed.begin(), allowed.end(), value) != allowed.end()) return; std::string list; for (const auto& a : allowed) list += (list.empty() ? "" : ", ") + a; throw fw::ValidationError({{field, "must be one of: " + list}}); } // One button (with its inputs) on a lab page and the handler behind it. class ActionSpec { public: ActionSpec(std::string sub, std::string label) : sub_(std::move(sub)), label_(std::move(label)) {} ActionSpec& num(const std::string& name, const std::string& label, long lo, long hi, const std::string& def, const std::string& hint = "") { model_.push_back({name, fw::FieldType::Integer, false, 0, 1024, lo, hi, true, def}); form_.push_back({name, label, "number", hint.empty() ? std::to_string(lo) + " to " + std::to_string(hi) : hint}); defaults_[name] = def; return *this; } ActionSpec& text(const std::string& name, const std::string& label, std::size_t min, std::size_t max, const std::string& def, const std::string& hint = "", bool required = true) { model_.push_back({name, fw::FieldType::String, required, min, max, 0, 0, false, required ? "" : def}); form_.push_back({name, label, "text", hint}); defaults_[name] = def; return *this; } ActionSpec& run(std::function fn) { run_ = std::move(fn); return *this; } ActionSpec& dynamic_defaults(std::function fn) { dyn_ = std::move(fn); return *this; } const std::string& sub() const { return sub_; } const std::string& label() const { return label_; } const std::vector& form() const { return form_; } fw::Model model() const { return fw::Model(model_); } Params defaults() const { Params d = defaults_; if (dyn_) for (const auto& [k, v] : dyn_()) d[k] = v; return d; } std::string execute(const Params& p) const { return run_ ? run_(p) : ""; } private: std::string sub_, label_; std::vector model_; std::vector form_; Params defaults_; std::function dyn_; std::function run_; }; class LabPage { public: LabPage(fw::Environment* env, std::string path, std::string title, std::string intro, std::shared_ptr lab) : env_(env), path_(std::move(path)), title_(std::move(title)), intro_(std::move(intro)), lab_(std::move(lab)) {} ActionSpec& action(std::string sub, std::string label) { actions_.emplace_back(std::move(sub), std::move(label)); return actions_.back(); } void extra_rows(std::function fn) { extra_ = std::move(fn); } fw::Response page(int status, const std::string& notice) const { fw::TemplateCtx ctx; ctx["title"] = title_; ctx["intro"] = intro_; ctx["notice"] = notice; fw::TemplateList rows, acts, log; fw::LabRows all = lab_->rows(); if (extra_) for (auto& r : extra_()) all.push_back(std::move(r)); for (const auto& [k, v] : all) rows.push_back({{"k", k}, {"v", v}}); for (const auto& a : actions_) acts.push_back({{"html", action_html(a)}}); for (const auto& l : lab_->log()) log.push_back({{"line", l}}); ctx["rows"] = rows; ctx["actions"] = acts; ctx["log"] = log; return fw::Response(status, env_->render("lab_page.html", ctx), "text/html; charset=utf-8"); } fw::Response invalid(const ActionSpec& a, const fw::Request& req, const fw::ValidationError& e) const { if (!wants_html(req)) return fw::JsonResponse(e.to_json(), 422); FormView v; v.title = a.label(); v.action = path_ + a.sub(); v.submit = a.label(); v.fields = a.form(); v.values = a.defaults(); for (const auto& [k, val] : fw::parse_form(req.body)) v.values[k] = val; v.error = &e; return fw::Response(422, env_->render("form_page.html", v.ctx()), "text/html; charset=utf-8"); } fw::Response handle(std::size_t i, const fw::Request& req) const { const ActionSpec& a = actions_[i]; std::string notice; try { notice = a.execute(fw::Form(a.model()).bind(req)); } catch (const fw::ValidationError& e) { return invalid(a, req, e); } if (!wants_html(req)) return fw::JsonResponse(lab_->json(), 200); return page(200, notice); } void mount(fw::Router& router, const std::shared_ptr& self, const std::string& name) { router.get(path_, name, [self](fw::Request) { return self->page(200, ""); }); for (std::size_t i = 0; i < actions_.size(); ++i) router.post(path_ + actions_[i].sub(), name + actions_[i].sub(), [self, i](fw::Request req) { return self->handle(i, req); }); } private: std::string action_html(const ActionSpec& a) const { std::string h = "
"; Params d = a.defaults(); for (const auto& f : a.form()) { h += ""; } return h + "
"; } fw::Environment* env_; std::string path_, title_, intro_; std::shared_ptr lab_; std::deque actions_; // deque: stable references while adding std::function extra_; }; long to_long(const Params& p, const std::string& k) { return std::stol(p.at(k)); } // Builds, wires and registers one lab page in the index matrix. class Mounter { public: Mounter(fw::Router& router, Services& services, std::shared_ptr registry) : router_(router), services_(services), registry_(std::move(registry)) {} std::shared_ptr page(const std::string& feature, const std::string& path, const std::string& title, const std::string& intro, std::shared_ptr lab) { auto p = std::make_shared(services_.templates.get(), path, title, intro, std::move(lab)); pending_.push_back({p, feature, path}); return p; } void finish() { for (auto& e : pending_) { e.page->mount(router_, e.page, e.path); services_.add_feature(e.feature, e.path); } pending_.clear(); } private: struct Entry { std::shared_ptr page; std::string feature, path; }; fw::Router& router_; Services& services_; std::shared_ptr registry_; std::vector pending_; }; } // namespace void register_resilience_demo(fw::Router& router, Services& services) { services.templates->add_template("lab_page.html", kLabPage); auto registry = std::make_shared(); Mounter m(router, services, registry); // ---- operability: resilience ------------------------------------------- auto bclock = std::make_shared(); auto breaker = std::make_shared(bclock); registry->add(breaker); auto p = m.page("Circuit breaker", "/operability/breaker", "Circuit breaker", "Three failures open the breaker, calls are rejected while " "open, 30 s of injected clock time later it goes half-open " "and one good call closes it again.", breaker); p->action("/success", "Call succeeds").run([breaker](const Params&) { return breaker->call(true) ? "call recorded" : "rejected: breaker open"; }); p->action("/failure", "Call fails").run([breaker](const Params&) { return breaker->call(false) ? "failure recorded" : "rejected: breaker open"; }); p->action("/tick", "Advance 10 s").run([breaker](const Params&) { breaker->tick(10000); return "clock advanced 10 s"; }); auto bulkhead = std::make_shared(); registry->add(bulkhead); p = m.page("Bulkhead", "/operability/bulkhead", "Bulkhead", "Two concurrent slots and a queue of one; the fourth caller is " "rejected instead of starving the rest.", bulkhead); p->action("/acquire", "Take a slot").run([bulkhead](const Params&) { switch (bulkhead->acquire()) { case fw::Bulkhead::Admission::Admitted: return "admitted"; case fw::Bulkhead::Admission::Queued: return "queued"; default: return "rejected: compartment full"; } }); p->action("/release", "Release a slot").run([bulkhead](const Params&) { return bulkhead->release() ? "released" : "nothing to release"; }); auto shedder = std::make_shared(); registry->add(shedder); p = m.page("Load shedder", "/operability/shedder", "Load shedder", "Limit 3 in flight. Low priority work is shed first (at 2), high " "priority only at the limit.", shedder); p->action("/enter", "Start request") .text("priority", "Priority", 1, 8, "low", "low or high", false) .run([shedder](const Params& q) { require_in("priority", q.at("priority"), {"low", "high"}); return shedder->enter(q.at("priority") == "high") ? "accepted" : "shed"; }); p->action("/leave", "Finish request").run([shedder](const Params&) { return shedder->leave() ? "finished" : "nothing in flight"; }); auto deadline = std::make_shared(); registry->add(deadline); p = m.page("Deadline propagation", "/operability/deadline", "Deadline propagation", "One budget travels through every hop; each hop costs 30 ms and a " "hop that cannot finish in time is skipped.", deadline); p->action("/run", "Run chain") .num("budget_ms", "Budget ms", 0, 5000, "100") .num("hops", "Hops", 1, 10, "3") .run([deadline](const Params& q) { int hop = deadline->run(to_long(q, "budget_ms"), (int)to_long(q, "hops")); return hop ? "deadline exceeded at hop " + std::to_string(hop) : std::string("all hops finished in budget"); }); auto slo = std::make_shared(); registry->add(slo); p = m.page("SLO error budget", "/operability/slo", "SLO error budget", "95.0% target over the last 100 events. The error budget is how " "many bad events the window still allows.", slo); p->action("/good", "Good event").run([slo](const Params&) { slo->record(true); return "good event recorded"; }); p->action("/bad", "Bad event").run([slo](const Params&) { slo->record(false); return "bad event recorded"; }); p->action("/reset", "Reset window").run([slo](const Params&) { slo->reset(); return "window reset"; }); // ---- operability: chaos, deploy, coordination --------------------------- auto chaos = std::make_shared(); registry->add(chaos); p = m.page("Chaos experiment", "/operability/chaos", "Chaos experiment", "Fault injection with a hard blast radius: at most 50 percent and " "5 faults over 10 calls. Armed 0 is a dry run and injects nothing.", chaos); p->action("/run", "Run experiment") .num("percent", "Percent", 0, fw::labcaps::kMaxPercent, "20") .num("max_faults", "Max faults", 1, fw::labcaps::kMaxFaults, "2") .num("armed", "Armed", 0, 1, "0", "0 dry run, 1 armed") .run([chaos](const Params& q) { auto r = chaos->run((int)to_long(q, "percent"), (int)to_long(q, "max_faults"), to_long(q, "armed") == 1); return std::string(r.armed ? "armed: " : "dry run: ") + std::to_string(r.injected) + " injected, " + std::to_string(r.planned) + " planned"; }); auto deploy = std::make_shared(); registry->add(deploy); p = m.page("Deploy strategies", "/operability/deploy", "Deploy strategies", "Rolling replaces one instance per step; blue-green prepares a " "green fleet and switches in one step. Rollback restores the " "previous fleet.", deploy); p->action("/start", "Start rollout") .text("strategy", "Strategy", 1, 16, "rolling", "rolling or bluegreen", false) .text("version", "Version", 1, 16, "v2", "", false) .run([deploy](const Params& q) { require_in("strategy", q.at("strategy"), {"rolling", "bluegreen"}); return deploy->start(q.at("strategy"), q.at("version")) ? "rollout started" : "a rollout is already in progress"; }); p->action("/step", "Next step").run([deploy](const Params&) { return deploy->step() ? "step done" : "no rollout in progress"; }); p->action("/rollback", "Roll back").run([deploy](const Params&) { return deploy->rollback() ? "rolled back" : "nothing to roll back"; }); auto cclock = std::make_shared(); auto coord = std::make_shared(cclock); registry->add(coord); p = m.page("Lease, election, fenced lock", "/operability/coord", "Coordination", "Lease, leader election and distributed lock share one rule: a " "new holder gets a higher fencing token, and writes with a stale " "token are rejected. Leases last 10 s of injected time.", coord); p->action("/acquire", "Acquire") .text("key", "Key", 1, 16, "lock", "lease, lock or leader", false) .text("owner", "Owner", 1, 32, "a", "", true) .run([coord](const Params& q) { require_in("key", q.at("key"), {"lease", "lock", "leader"}); auto g = coord->acquire(q.at("key"), q.at("owner")); return g.ok ? "granted token " + std::to_string(g.token) : "denied, held by " + g.holder; }); p->action("/release", "Release") .text("key", "Key", 1, 16, "lock", "lease, lock or leader", false) .text("owner", "Owner", 1, 32, "a", "", true) .run([coord](const Params& q) { require_in("key", q.at("key"), {"lease", "lock", "leader"}); return coord->release(q.at("key"), q.at("owner")) ? "released" : "not the holder"; }); p->action("/write", "Fenced write") .text("key", "Key", 1, 16, "lock", "lease, lock or leader", false) .num("token", "Token", 0, 1000000, "1") .run([coord](const Params& q) { require_in("key", q.at("key"), {"lease", "lock", "leader"}); return coord->write(q.at("key"), to_long(q, "token")) ? "write accepted" : "write rejected: stale fencing token"; }); p->action("/tick", "Advance 6 s").run([coord](const Params&) { coord->tick(6000); return "clock advanced 6 s"; }); // ---- supply chain ------------------------------------------------------- auto supply = std::make_shared(); registry->add(supply); p = m.page("Supply chain gate", "/supplychain", "Supply chain gate", "Illustrative SBOM of this example (CycloneDX shape), dependency " "pins, an advisory scan and an attestation check. The gate passes " "only when all three pass. The digest is FNV-1a, not a signature.", supply); p->action("/advisory", "Publish advisory for chartjs 4.4.1") .run([supply](const Params&) { return supply->add_advisory("chartjs", "4.4.1") ? "advisory published" : "advisory db full"; }); p->action("/tamper", "Tamper with chartjs").run([supply](const Params&) { supply->tamper(); return "component changed after attestation"; }); p->action("/verify", "Verify attestation") .text("digest", "Digest", 16, 16, "", "16 hex characters of sbom_digest") .dynamic_defaults([supply] { return Params{{"digest", supply->attested()}}; }) .run([supply](const Params& q) { return supply->verify(q.at("digest")) ? "attestation verified" : "attestation FAILED"; }); p->action("/reset", "Regenerate and attest").run([supply](const Params&) { supply->reset(); return "sbom regenerated"; }); router.get("/supplychain/sbom.json", "supplychain-sbom", [supply](fw::Request) { return fw::JsonResponse(supply->cyclonedx(), 200); }); // ---- clients depth ------------------------------------------------------ auto retry = std::make_shared(); registry->add(retry); p = m.page("Client retry and backoff", "/clients/retry", "Client retry and backoff", "In-process transport that fails the first N calls. 5xx is " "retried with doubling backoff capped at 800 ms and at most 5 " "attempts; 4xx is never retried. Waits are virtual.", retry); p->action("/run", "Send request") .num("failures", "Failures", 0, 10, "2") .num("max_attempts", "Max attempts", 1, fw::labcaps::kMaxAttempts, "3") .num("status", "Failure status", 400, 599, "503") .run([retry](const Params& q) { auto o = retry->run((int)to_long(q, "failures"), (int)to_long(q, "max_attempts"), (int)to_long(q, "status")); return "final status " + std::to_string(o.status) + " after " + std::to_string(o.attempts) + " attempt(s)"; }); auto session = std::make_shared(); registry->add(session); p = m.page("Client session: cookies, pool, proxy, auth", "/clients/session", "Client session", "Each request goes through the in-process transport: the server " "sets cookies into the jar, connections are pooled and reused, a " "proxy change opens a new connection, and the auth scheme sets the " "Authorization header.", session); p->action("/request", "Send request") .text("auth", "Auth", 1, 8, "none", "none, basic or bearer", false) .text("proxy", "Proxy", 0, 80, "", "http://host:port or empty", false) .run([session](const Params& q) { require_in("auth", q.at("auth"), {"none", "basic", "bearer"}); auto px = q.count("proxy") ? q.at("proxy") : std::string(); if (!fw::ClientSessionLab::valid_proxy(px)) throw fw::ValidationError( {{"proxy", "must be empty or http(s)/socks5://host:port"}}); auto h = session->request(q.at("auth"), px); std::string out = "sent:"; for (const auto& [k, v] : h) out += " " + k + "=" + v + ";"; return out; }); // ---- data depth --------------------------------------------------------- auto mig = std::make_shared(); registry->add(mig); p = m.page("Migrations: check then apply", "/data/migrations", "Migrations", "Preview shows what apply would run without changing anything. " "Apply runs pending steps in order. Drift drops a table out of " "band and heal re-creates it from its migration.", mig); p->extra_rows([mig] { fw::LabRows r; for (const auto& line : mig->check()) r.emplace_back("preview", line); return r; }); p->action("/apply", "Apply") .num("limit", "Steps", 1, 3, "3") .run([mig](const Params& q) { int n = mig->apply((int)to_long(q, "limit")); return std::to_string(n) + " migration(s) applied"; }); p->action("/drift", "Drop posts table").run([mig](const Params&) { mig->drop_table("posts"); return "posts dropped out of band"; }); p->action("/heal", "Heal drift").run([mig](const Params&) { return std::to_string(mig->heal()) + " table(s) healed"; }); auto tx = std::make_shared(); registry->add(tx); p = m.page("Transaction rollback", "/data/transaction", "Transaction rollback", "Transfer between alice and bob inside a transaction. Overdrafts " "and a failure after the debit roll back, so no money is lost.", tx); p->action("/transfer", "Transfer") .text("from", "From", 1, 8, "alice", "alice or bob", false) .text("to", "To", 1, 8, "bob", "alice or bob", false) .num("amount", "Amount", 1, 1000, "30") .num("fail_after_debit", "Fail after debit", 0, 1, "0", "0 or 1") .run([tx](const Params& q) { require_in("from", q.at("from"), {"alice", "bob"}); require_in("to", q.at("to"), {"alice", "bob"}); if (q.at("from") == q.at("to")) throw fw::ValidationError({{"to", "must differ from the source"}}); return tx->transfer(q.at("from"), q.at("to"), to_long(q, "amount"), to_long(q, "fail_after_debit") == 1); }); auto query = std::make_shared(); registry->add(query); p = m.page("Query builder and relations", "/data/query", "Query builder and relations", "Builds a joined SELECT over users has-many posts and runs it on " "in-memory tables. User 0 means all users.", query); p->action("/run", "Run query") .num("user_id", "User id", 0, 2, "0") .text("order", "Order", 1, 8, "id", "id or title", false) .num("limit", "Limit", 1, 10, "5") .run([query](const Params& q) { require_in("order", q.at("order"), {"id", "title"}); auto r = query->run(to_long(q, "user_id"), q.at("order"), (int)to_long(q, "limit")); return std::to_string(r.rows.size()) + " row(s)"; }); auto flight = std::make_shared(); registry->add(flight); p = m.page("Singleflight", "/data/singleflight", "Singleflight", "Concurrent callers asking for the same key share one load. The " "loader waits for the other callers to join, so the result is " "deterministic. At most 16 threads.", flight); p->action("/run", "Run callers") .num("callers", "Callers", 1, fw::labcaps::kMaxThreads, "8") .run([flight](const Params& q) { int callers = (int)to_long(q, "callers"); int loads = flight->run(callers); return std::to_string(callers) + " callers, " + std::to_string(loads) + " load(s)"; }); auto tclock = std::make_shared(); auto ttl = std::make_shared(tclock); registry->add(ttl); p = m.page("TTL store, LRU, pubsub", "/data/ttl", "TTL store", "Memory store with per-key TTL on injected time, LRU eviction at " "5 entries, and a pubsub topic kv.events announcing every change.", ttl); p->extra_rows([ttl] { fw::LabRows r; for (const auto& e : ttl->events()) r.emplace_back("event", e); return r; }); p->action("/set", "Set key") .text("key", "Key", 1, 16, "", "", true) .text("value", "Value", 1, 32, "", "", true) .num("ttl_s", "TTL s", 1, 60, "10") .run([ttl](const Params& q) { ttl->set(q.at("key"), q.at("value"), to_long(q, "ttl_s")); return "stored " + q.at("key"); }); p->action("/get", "Get key") .text("key", "Key", 1, 16, "", "", true) .run([ttl](const Params& q) { std::string v; return ttl->get(q.at("key"), v) ? "hit: " + v : std::string("miss"); }); p->action("/tick", "Advance 5 s").run([ttl](const Params&) { ttl->tick(5000); return "clock advanced 5 s"; }); m.finish(); router.get("/operability/debug", "operability-debug", [registry](fw::Request) { return fw::JsonResponse(registry->snapshot(), 200); }); services.add_feature("Debug snapshot", "/operability/debug"); } } // namespace molo::example::app