// ADR-0182 read-only admin API and portal host for one world (DEV). // // evo-admin-api --listen ADDRESS:PORT --world N --jwks JSON --oidc-issuer URL // --audience NAME --client NAME --role NAME --assets DIR // --pg-passfile F --pg-service F [--region REGION=HOST:PORT ...] // // --assets holds the portal's index.html, app.js and style.css. Each --region names a // region's operations address, whose /admin/view the portal may show. No token is printed. #include "evo/persistence/postgres.hpp" #include "evo/server/admin/admin_api.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include namespace { using namespace evo; using namespace std::chrono_literals; volatile std::sig_atomic_t stop_requested = 0; void on_stop(int) { stop_requested = 1; } struct Options { std::string listen, jwks, oidc_issuer, audience, client, role, assets; std::uint64_t world{}; std::map regions; // Region to its operations address. persistence::PgOptions pg; }; std::optional number(std::string_view text) { std::uint64_t value{}; const auto [end, error] = std::from_chars(text.data(), text.data() + text.size(), value); if (error != std::errc{} || end != text.data() + text.size()) return std::nullopt; return value; } std::optional parse(int argc, char** argv) { Options o; std::string pg_service, pg_passfile; for (int i = 1; i + 1 < argc; i += 2) { const std::string_view flag = argv[i]; const std::string_view value = argv[i + 1]; const auto n = number(value); if (flag == "--listen") o.listen = value; else if (flag == "--world" && n && *n > 0) o.world = *n; else if (flag == "--jwks") o.jwks = value; else if (flag == "--oidc-issuer") o.oidc_issuer = value; else if (flag == "--audience") o.audience = value; else if (flag == "--client") o.client = value; else if (flag == "--role") o.role = value; else if (flag == "--assets") o.assets = value; else if (flag == "--pg-service") pg_service = value; else if (flag == "--pg-passfile") pg_passfile = value; else if (flag == "--region") { const auto equals = value.find('='); const auto region = equals == std::string_view::npos ? std::nullopt : number(value.substr(0, equals)); const auto address = equals == std::string_view::npos ? std::string_view{} : value.substr(equals + 1); if (!region || *region == 0 || address.empty() || address.size() > 128 || !o.regions.emplace(*region, std::string(address)).second) return std::nullopt; } else return std::nullopt; } // Names are embedded in the portal's JSON settings: printable ASCII without quotes. const auto plain = [](std::string_view text) { return !text.empty() && text.size() <= 256 && std::ranges::all_of(text, [](char ch) { return ch > ' ' && ch <= '~' && ch != '"' && ch != '\\'; }); }; if (argc % 2 != 1 || o.listen.empty() || o.world == 0 || o.jwks.empty() || !plain(o.oidc_issuer) || !o.oidc_issuer.starts_with("https://") || !plain(o.audience) || !plain(o.client) || !plain(o.role) || o.assets.empty() || pg_service.empty() || pg_passfile.empty()) return std::nullopt; auto service = persistence::read_pg_service(pg_service, "evolution"); if (!service) return std::nullopt; o.pg = *service; o.pg.password_file = pg_passfile; return o; } std::optional read_file(const std::string& path) { std::ifstream file{path, std::ios::binary}; if (!file) return std::nullopt; std::string body{std::istreambuf_iterator{file}, std::istreambuf_iterator{}}; if (body.empty() || body.size() > (std::size_t{1} << 20U)) return std::nullopt; return body; } std::uint64_t wall_seconds() { return static_cast(std::chrono::duration_cast( std::chrono::system_clock::now().time_since_epoch()) .count()); } } // namespace int main(int argc, char** argv) { const auto options = parse(argc, argv); if (!options) { std::fputs("usage: evo-admin-api (see apps/evo-admin-api/main.cpp)\n", stderr); return 2; } std::signal(SIGTERM, on_stop); std::signal(SIGINT, on_stop); std::signal(SIGPIPE, SIG_IGN); auto verifier = server::broker::TokenVerifier::from_jwks( options->jwks, {options->oidc_issuer, options->audience, options->client, 30, options->role}); if (!verifier) { std::puts("error jwks"); return 2; } std::vector assets; for (const auto& [name, type] : {std::pair{"index.html", "text/html; charset=utf-8"}, std::pair{"app.js", "text/javascript; charset=utf-8"}, std::pair{"style.css", "text/css; charset=utf-8"}}) { auto body = read_file(options->assets + "/" + name); if (!body) { std::printf("error assets %s\n", name); return 2; } assets.push_back({std::string("/") + name, type, std::move(*body)}); } // The realm's origin: sign-in redirects there and the portal exchanges tokens with it. const auto origin_end = options->oidc_issuer.find('/', std::string_view{"https://"}.size()); const auto origin = options->oidc_issuer.substr(0, origin_end); server::admin::AdminConfig config; config.world = options->world; for (const auto& [region, address] : options->regions) config.view_regions.push_back(region); config.portal_config_json = "{\"issuer\":\"" + options->oidc_issuer + "\",\"client_id\":\"" + options->client + "\",\"world\":" + std::to_string(options->world) + "}\n"; config.content_security_policy = "default-src 'none'; script-src 'self'; style-src 'self'; img-src 'self' data:; " "connect-src 'self' " + origin + "; form-action 'self' " + origin + "; frame-ancestors 'none'; base-uri 'none'"; auto listening = server::OpsServer::listen(options->listen, server::OpsServer::max_configurable_response_bytes); if (!listening) { std::puts("error listen"); return 2; } const auto pg = options->pg; const auto regions = options->regions; server::admin::AdminApi api{std::move(config), std::move(*verifier), [pg]() -> std::unique_ptr { auto db = persistence::Postgres::connect(pg, 3s); return db ? std::move(*db) : nullptr; }, [regions](std::uint64_t region) -> std::optional { const auto found = regions.find(region); if (found == regions.end()) return std::nullopt; return server::admin::http_get( found->second, "/admin/view", 1500ms, server::OpsServer::max_configurable_response_bytes); }, std::move(assets)}; std::printf("admin api listening %u world %llu\n", static_cast((*listening)->port()), static_cast(options->world)); std::fflush(stdout); while (stop_requested == 0) { (*listening)->serve_api([&](const server::ApiRequest& request) { return api.handle(request, wall_seconds(), std::chrono::steady_clock::now()); }); std::this_thread::sleep_for(5ms); } std::puts("admin api stopped"); return 0; }