#include "Platform.hpp" #include #include #include #include namespace molo::example::fw { namespace { std::string lower(std::string s) { for (char& c : s) c = (char)std::tolower((unsigned char)c); return s; } std::string trim(const std::string& s) { std::size_t a = s.find_first_not_of(" \t"); if (a == std::string::npos) return ""; return s.substr(a, s.find_last_not_of(" \t") - a + 1); } std::vector split(const std::string& s, char sep) { std::vector out; std::size_t start = 0; while (true) { std::size_t at = s.find(sep, start); out.push_back(trim(s.substr(start, at == std::string::npos ? at : at - start))); if (at == std::string::npos) break; start = at + 1; } return out; } // "gzip;q=0.5" -> token "gzip", q 0.5. Missing q is 1. void token_q(const std::string& part, std::string& token, double& q) { std::size_t semi = part.find(';'); token = lower(trim(part.substr(0, semi))); q = 1.0; if (semi == std::string::npos) return; std::string rest = lower(trim(part.substr(semi + 1))); if (rest.rfind("q=", 0) == 0) q = std::atof(rest.c_str() + 2); } bool parse_size(const std::string& s, std::size_t& out) { if (s.empty() || s.size() > 15) return false; std::size_t v = 0; for (char c : s) { if (c < '0' || c > '9') return false; v = v * 10 + (std::size_t)(c - '0'); } out = v; return true; } std::string hex_pad(unsigned long long v, std::size_t digits) { char buf[40]; std::snprintf(buf, sizeof(buf), "%0*llx", (int)digits, v); std::string s = buf; return s.substr(s.size() - digits); } } // namespace // ---- i18n ----------------------------------------------------------------- int PluralRule::forms(const std::string& locale) { if (locale == "ru") return 3; if (locale == "ja") return 1; return 2; } int PluralRule::index(const std::string& locale, long n) { if (n < 0) n = -n; if (locale == "ja") return 0; if (locale == "fr") return n < 2 ? 0 : 1; if (locale == "ru") { if (n % 10 == 1 && n % 100 != 11) return 0; if (n % 10 >= 2 && n % 10 <= 4 && (n % 100 < 12 || n % 100 > 14)) return 1; return 2; } return n == 1 ? 0 : 1; } bool MessageCatalog::add(const std::string& locale, const std::string& msgid, std::vector forms) { if (!data_.count(locale) && data_.size() >= platform_caps::kMaxLocales) return false; auto& msgs = data_[locale]; if (!msgs.count(msgid) && msgs.size() >= platform_caps::kMaxMessages) return false; msgs[msgid] = std::move(forms); return true; } std::string MessageCatalog::translate(const std::string& locale, const std::string& msgid, long n) const { for (const std::string& loc : {locale, default_}) { auto l = data_.find(loc); if (l == data_.end()) continue; auto m = l->second.find(msgid); if (m == l->second.end() || m->second.empty()) continue; std::size_t idx = (std::size_t)PluralRule::index(loc, n); const std::string& form = m->second[std::min(idx, m->second.size() - 1)]; std::string out = form; std::size_t at = out.find("%d"); if (at != std::string::npos) out.replace(at, 2, std::to_string(n)); return out; } return msgid; } std::vector MessageCatalog::locales() const { std::vector out; for (const auto& [k, v] : data_) out.push_back(k); return out; } bool MessageCatalog::has_locale(const std::string& locale) const { return data_.count(locale) > 0; } std::string MessageCatalog::to_po(const std::string& locale) const { auto l = data_.find(locale); std::string out = "msgid \"\"\nmsgstr \"\"\n\"Language: " + locale + "\\n\"\n\"Plural-Forms: nplurals=" + std::to_string(PluralRule::forms(locale)) + ";\\n\"\n"; if (l == data_.end()) return out; for (const auto& [id, forms] : l->second) { out += "\nmsgid \"" + id + "\"\n"; if (forms.size() == 1) { out += "msgstr \"" + forms[0] + "\"\n"; } else { out += "msgid_plural \"" + id + "\"\n"; for (std::size_t i = 0; i < forms.size(); ++i) out += "msgstr[" + std::to_string(i) + "] \"" + forms[i] + "\"\n"; } } return out; } void MessageCatalog::set_default(std::string locale) { default_ = std::move(locale); } const std::string& MessageCatalog::default_locale() const { return default_; } std::string negotiate_locale(const std::string& lang_param, const std::string& accept_language, const MessageCatalog& catalog) { std::string forced = lower(lang_param); if (catalog.has_locale(forced)) return forced; std::string best = catalog.default_locale(); double best_q = 0; for (const std::string& part : split(accept_language, ',')) { if (part.empty()) continue; std::string tag; double q; token_q(part, tag, q); std::string primary = tag.substr(0, tag.find('-')); std::string pick = catalog.has_locale(tag) ? tag : catalog.has_locale(primary) ? primary : ""; if (!pick.empty() && q > best_q) { best = pick; best_q = q; } } return best; } // ---- compression ---------------------------------------------------------- std::uint32_t crc32(const std::string& data) { std::uint32_t crc = 0xFFFFFFFFu; for (unsigned char c : data) { crc ^= c; for (int k = 0; k < 8; ++k) crc = (crc >> 1) ^ (0xEDB88320u & (0u - (crc & 1u))); } return ~crc; } namespace { void put_le32(std::string& out, std::uint32_t v) { for (int i = 0; i < 4; ++i) out.push_back((char)((v >> (8 * i)) & 0xFF)); } } // namespace std::string gzip_stored(const std::string& data) { std::string out("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff", 10); std::size_t pos = 0; do { std::size_t n = std::min(65535, data.size() - pos); bool last = pos + n >= data.size(); out.push_back(last ? 1 : 0); out.push_back((char)(n & 0xFF)); out.push_back((char)(n >> 8)); out.push_back((char)(~n & 0xFF)); out.push_back((char)((~n >> 8) & 0xFF)); out.append(data, pos, n); pos += n; } while (pos < data.size()); put_le32(out, crc32(data)); put_le32(out, (std::uint32_t)data.size()); return out; } bool accepts_encoding(const std::string& accept_encoding, const std::string& coding) { bool star = false; for (const std::string& part : split(accept_encoding, ',')) { std::string tag; double q; token_q(part, tag, q); if (tag == coding) return q > 0; if (tag == "*" && q > 0) star = true; } return star; } // ---- conditional GET and ranges ------------------------------------------- std::string make_etag(const std::string& body) { std::uint64_t h = 1469598103934665603ull; for (unsigned char c : body) { h ^= c; h *= 1099511628211ull; } return "\"" + hex_pad(h, 16) + "-" + std::to_string(body.size()) + "\""; } bool etag_matches(const std::string& header, const std::string& etag) { if (trim(header) == "*") return true; for (std::string tag : split(header, ',')) { if (tag.rfind("W/", 0) == 0) tag = tag.substr(2); if (!tag.empty() && tag == etag) return true; } return false; } ByteRange parse_range(const std::string& header, std::size_t size) { ByteRange r; if (header.rfind("bytes=", 0) != 0) return r; std::string spec = trim(header.substr(6)); if (spec.find(',') != std::string::npos) return r; std::size_t dash = spec.find('-'); if (dash == std::string::npos) return r; std::string a = spec.substr(0, dash), b = spec.substr(dash + 1); std::size_t first = 0, last = 0; if (a.empty()) { std::size_t n; if (!parse_size(b, n)) return r; r.kind = (n == 0 || size == 0) ? ByteRange::Kind::Unsatisfiable : ByteRange::Kind::Ok; if (r.kind == ByteRange::Kind::Ok) { r.first = n >= size ? 0 : size - n; r.last = size - 1; } return r; } if (!parse_size(a, first)) return r; if (b.empty()) { last = size ? size - 1 : 0; } else if (!parse_size(b, last)) { return r; } if (first >= size || first > last) { r.kind = ByteRange::Kind::Unsatisfiable; return r; } r.kind = ByteRange::Kind::Ok; r.first = first; r.last = std::min(last, size - 1); return r; } // ---- health probes -------------------------------------------------------- bool HealthRegistry::add_check(const std::string& name, bool up) { std::lock_guard lock(mu_); if (!checks_.count(name) && checks_.size() >= platform_caps::kMaxChecks) return false; checks_[name] = up; return true; } bool HealthRegistry::set_check(const std::string& name, bool up) { std::lock_guard lock(mu_); auto it = checks_.find(name); if (it == checks_.end()) return false; it->second = up; return true; } bool HealthRegistry::add_startup_task(const std::string& name, bool done) { std::lock_guard lock(mu_); if (!tasks_.count(name) && tasks_.size() >= platform_caps::kMaxChecks) return false; tasks_[name] = done; return true; } bool HealthRegistry::set_startup_task(const std::string& name, bool done) { std::lock_guard lock(mu_); auto it = tasks_.find(name); if (it == tasks_.end()) return false; it->second = done; return true; } bool HealthRegistry::startup_complete() const { std::lock_guard lock(mu_); for (const auto& [k, v] : tasks_) if (!v) return false; return true; } bool HealthRegistry::ready() const { if (!startup_complete()) return false; std::lock_guard lock(mu_); for (const auto& [k, v] : checks_) if (!v) return false; return true; } namespace { std::string bool_map_json(const std::map& m, const char* up, const char* down) { std::string out = "{"; bool first = true; for (const auto& [k, v] : m) { out += std::string(first ? "" : ",") + "\"" + json_escape(k) + "\":\"" + (v ? up : down) + "\""; first = false; } return out + "}"; } } // namespace std::string HealthRegistry::liveness_json() const { long up = (long)std::chrono::duration_cast( std::chrono::steady_clock::now() - started_) .count(); return "{\"status\":\"alive\",\"uptime_seconds\":" + std::to_string(up) + "}"; } std::string HealthRegistry::readiness_json() const { bool ok = ready(); std::lock_guard lock(mu_); return std::string("{\"status\":\"") + (ok ? "ready" : "not_ready") + "\",\"checks\":" + bool_map_json(checks_, "up", "down") + "}"; } std::string HealthRegistry::startup_json() const { bool ok = startup_complete(); std::lock_guard lock(mu_); return std::string("{\"status\":\"") + (ok ? "started" : "starting") + "\",\"tasks\":" + bool_map_json(tasks_, "done", "pending") + "}"; } // ---- Prometheus ----------------------------------------------------------- PrometheusExporter::PrometheusExporter(const Metrics* metrics, const Stats* stats) : metrics_(metrics), stats_(stats) {} std::string PrometheusExporter::sanitize(const std::string& name) { std::string out; for (char c : name) { bool ok = std::isalnum((unsigned char)c) || c == '_' || c == ':'; out.push_back(ok ? c : '_'); } if (out.empty() || std::isdigit((unsigned char)out[0])) out.insert(0, "_"); return out; } std::string PrometheusExporter::render() const { std::string out; auto sample = [&out](const std::string& name, const char* type, const std::string& help, const std::string& value) { out += "# HELP " + name + " " + help + "\n# TYPE " + name + " " + type + "\n" + name + " " + value + "\n"; }; sample("molo_http_requests_total", "counter", "Requests served.", std::to_string(stats_->total_requests())); sample("molo_http_connections_total", "counter", "Connections accepted.", std::to_string(stats_->total_connections())); sample("molo_http_connections_active", "gauge", "Open connections.", std::to_string(stats_->active_connections())); for (const auto& [k, v] : metrics_->snapshot()) { char buf[64]; std::snprintf(buf, sizeof(buf), "%g", v); sample("molo_example_" + sanitize(k), "gauge", "Example metric " + k + ".", buf); } return out; } // ---- structured logging --------------------------------------------------- bool parse_level(const std::string& name, LogLevel& out) { std::string n = lower(name); if (n == "debug") out = LogLevel::Debug; else if (n == "info") out = LogLevel::Info; else if (n == "warn") out = LogLevel::Warn; else if (n == "error") out = LogLevel::Error; else return false; return true; } std::string level_name(LogLevel level) { switch (level) { case LogLevel::Debug: return "debug"; case LogLevel::Info: return "info"; case LogLevel::Warn: return "warn"; case LogLevel::Error: return "error"; } return "info"; } std::string LogRing::redact(const std::string& message) { static const char* keys[] = {"password", "passwd", "token", "secret", "authorization", "api_key", "apikey"}; std::string out = message; std::string low = lower(out); for (const char* key : keys) { std::string k = key; std::size_t from = 0; while ((from = low.find(k, from)) != std::string::npos) { std::size_t p = from + k.size(); from = p; if (p >= out.size() || (out[p] != '=' && out[p] != ':')) continue; ++p; while (p < out.size() && out[p] == ' ') ++p; std::size_t e = p; while (e < out.size() && !std::isspace((unsigned char)out[e]) && out[e] != ',' && out[e] != ';' && out[e] != '&') ++e; out.replace(p, e - p, "***"); low = lower(out); from = p; } } return out; } void LogRing::log(LogLevel level, std::string message, std::string correlation_id) { std::lock_guard lock(mu_); if (level < min_) { ++filtered_; return; } LogRecord r; r.seq = next_seq_++; r.ts = (long)std::chrono::duration_cast( std::chrono::system_clock::now().time_since_epoch()) .count(); r.level = level; if (message.size() > platform_caps::kLogMessage) message.resize(platform_caps::kLogMessage); r.message = redact(message); r.correlation_id = std::move(correlation_id); ring_.push_back(std::move(r)); while (ring_.size() > platform_caps::kLogRing) ring_.pop_front(); } std::vector LogRing::last(std::size_t n, LogLevel min) const { std::lock_guard lock(mu_); std::vector out; for (auto it = ring_.rbegin(); it != ring_.rend() && out.size() < n; ++it) if (it->level >= min) out.push_back(*it); return out; } void LogRing::set_min_level(LogLevel level) { std::lock_guard lock(mu_); min_ = level; } LogLevel LogRing::min_level() const { std::lock_guard lock(mu_); return min_; } std::size_t LogRing::size() const { std::lock_guard lock(mu_); return ring_.size(); } unsigned long LogRing::dropped_below_min() const { std::lock_guard lock(mu_); return filtered_; } std::string LogRing::to_json(const LogRecord& r) { return "{\"seq\":" + std::to_string(r.seq) + ",\"ts\":" + std::to_string(r.ts) + ",\"level\":\"" + level_name(r.level) + "\",\"msg\":\"" + json_escape(r.message) + "\",\"correlation_id\":\"" + json_escape(r.correlation_id) + "\"}"; } // ---- trace context -------------------------------------------------------- std::string TraceContext::traceparent() const { return "00-" + trace_id + "-" + span_id + "-" + flags; } std::string TraceContextFactory::next_hex(std::size_t digits) { unsigned long long v = ++counter_; v *= 0x9E3779B97F4A7C15ull; std::string out = hex_pad(v, 16); while (out.size() < digits) out += hex_pad(v * (out.size() + 7), 16); return out.substr(0, digits); } TraceContext TraceContextFactory::from_header(const std::string& header) { std::lock_guard lock(mu_); TraceContext ctx; ctx.had_parent = !header.empty(); auto parts = split(header, '-'); auto is_hex = [](const std::string& s) { return !s.empty() && std::all_of(s.begin(), s.end(), [](char c) { return std::isxdigit((unsigned char)c) && !std::isupper((unsigned char)c); }); }; bool ok = parts.size() == 4 && parts[0].size() == 2 && is_hex(parts[0]) && parts[0] != "ff" && parts[1].size() == 32 && is_hex(parts[1]) && parts[1] != std::string(32, '0') && parts[2].size() == 16 && is_hex(parts[2]) && parts[2] != std::string(16, '0') && parts[3].size() == 2 && is_hex(parts[3]); if (ok) { ctx.trace_id = parts[1]; ctx.parent_span_id = parts[2]; ctx.flags = parts[3]; } else { ctx.parent_valid = !ctx.had_parent; ctx.trace_id = next_hex(32); } ctx.span_id = next_hex(16); return ctx; } // ---- DI registry ---------------------------------------------------------- std::string lifetime_name(Lifetime l) { switch (l) { case Lifetime::Singleton: return "singleton"; case Lifetime::Scoped: return "scoped"; case Lifetime::Transient: return "transient"; } return "singleton"; } bool ServiceRegistry::add(const std::string& name, Lifetime lifetime, std::function factory) { std::lock_guard lock(mu_); if (!slots_.count(name) && slots_.size() >= platform_caps::kMaxServices) return false; Slot s; s.lifetime = lifetime; s.factory = std::move(factory); slots_[name] = std::move(s); return true; } bool ServiceRegistry::resolve(const std::string& name, const std::string& scope, std::string& out) { std::lock_guard lock(mu_); auto it = slots_.find(name); if (it == slots_.end()) return false; Slot& s = it->second; ++s.resolved; if (s.lifetime == Lifetime::Singleton) { if (!s.built) { s.instance = s.factory(); s.built = true; ++s.created; } out = s.instance; } else if (s.lifetime == Lifetime::Scoped) { auto sc = s.scoped.find(scope); if (sc == s.scoped.end()) { if (s.scoped.size() >= 16) s.scoped.clear(); sc = s.scoped.emplace(scope, s.factory()).first; ++s.created; } out = sc->second; } else { out = s.factory(); ++s.created; } return true; } std::vector ServiceRegistry::list() const { std::lock_guard lock(mu_); std::vector out; for (const auto& [k, s] : slots_) out.push_back({k, s.lifetime, s.created, s.resolved}); return out; } // ---- flash messages ------------------------------------------------------- std::string FlashCodec::encode(const std::string& message) { std::string m = message.substr(0, platform_caps::kFlashBytes); std::string out; for (unsigned char c : m) out += hex_pad(c, 2); return out; } bool FlashCodec::decode(const std::string& cookie, std::string& message) { if (cookie.empty() || cookie.size() % 2 || cookie.size() > platform_caps::kFlashBytes * 2) return false; std::string out; for (std::size_t i = 0; i < cookie.size(); i += 2) { if (!std::isxdigit((unsigned char)cookie[i]) || !std::isxdigit((unsigned char)cookie[i + 1])) return false; out.push_back((char)std::stoi(cookie.substr(i, 2), nullptr, 16)); } message = out; return true; } // ---- expose stats --------------------------------------------------------- namespace { constexpr std::size_t kBuckets = (std::size_t)(platform_caps::kExposeWindowSec / platform_caps::kExposeBucketSec); } ExposeStats::ExposeStats(long (*now_sec)()) : clock_(now_sec) {} void ExposeStats::set_clock(long (*now_sec)()) { clock_ = now_sec; } long ExposeStats::now() const { if (clock_) return clock_(); return (long)std::chrono::duration_cast( std::chrono::system_clock::now().time_since_epoch()) .count(); } bool ExposeStats::known_method(const std::string& m) { static const char* names[] = {"GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"}; for (const char* n : names) if (m == n) return true; return false; } bool ExposeStats::record(const std::string& method, unsigned long up, unsigned long down, unsigned long micros) { if (!known_method(method)) return false; std::lock_guard lock(mu_); ExposeRow& row = rows_[method]; ++row.count; row.bytes_up += up; row.bytes_down += down; row.micros += micros; auto& win = windows_[method]; if (win.empty()) win.resize(kBuckets); long slot = now() / platform_caps::kExposeBucketSec; Bucket& b = win[(std::size_t)slot % kBuckets]; if (b.slot != slot) b = Bucket{slot, 0, 0}; b.up += up; b.down += down; return true; } std::map ExposeStats::snapshot() const { std::lock_guard lock(mu_); std::map out; ExposeRow total; long cur = now() / platform_caps::kExposeBucketSec; for (const auto& [m, row] : rows_) { ExposeRow r = row; unsigned long up = 0, down = 0; for (const Bucket& b : windows_.at(m)) if (b.slot > cur - (long)kBuckets && b.slot <= cur) { up += b.up; down += b.down; } r.kb_s_up = up / 1024.0 / platform_caps::kExposeWindowSec; r.kb_s_down = down / 1024.0 / platform_caps::kExposeWindowSec; total.count += r.count; total.bytes_up += r.bytes_up; total.bytes_down += r.bytes_down; total.micros += r.micros; total.kb_s_up += r.kb_s_up; total.kb_s_down += r.kb_s_down; out[m] = r; } out["_total"] = total; return out; } } // namespace molo::example::fw