Unified Service Hosting

Add an optional on_shutdown callback to domain_service_runner. Called immediately after the shutdown signal is received, before nats.drain(). Needed by ores.http.server (to call server.stop() and event_source.stop()) and ores.compute.wrapper (to stop its work loop). The 15 existing callers pass nothing; the default is an empty std::function.

// domain_service_runner.hpp — updated signature (impl is additive)
template<typename RegisterFn>
boost::asio::awaitable<void>
run(boost::asio::io_context& io_ctx,
    ores::nats::service::client& nats,
    ores::database::context ctx,
    std::string_view name,
    RegisterFn&& register_fn,
    std::function<void(boost::asio::io_context&)> on_started  = {},
    std::function<void()>                          on_shutdown = {});

New step in domain_service_runner_impl.hpp between the signal wait and drain:

co_await signals.async_wait(boost::asio::use_awaitable);
BOOST_LOG_SEV(lg, info) << "Shutdown signal received. Draining...";
if (on_shutdown) on_shutdown();   // NEW
nats.drain();

An overload of run() for services that have no database (ores.compute.wrapper). The register_fn signature drops the ctx parameter.

// domain_service_runner.hpp — new overload declaration
template<typename RegisterFn>
boost::asio::awaitable<void>
run(boost::asio::io_context& io_ctx,
    ores::nats::service::client& nats,
    std::string_view name,
    RegisterFn&& register_fn,            // signature: (nats, verifier)
    std::function<void(boost::asio::io_context&)> on_started  = {},
    std::function<void()>                          on_shutdown = {});

Implementation in domain_service_runner_impl.hpp is identical to the existing overload, minus the ctx construction and pass-through.

A parallel runner for the one service that creates a JWT signer rather than fetching a verifier. The lifecycle is identical to domain_service_runner except step 2 (JWKS fetch) is replaced by constructing an RS256 signer from the service's private key. The register_fn receives a jwt_authenticator signer rather than a verifier.

// signing_service_runner.hpp
template<typename RegisterFn>
boost::asio::awaitable<void>
run_signing(boost::asio::io_context& io_ctx,
            ores::nats::service::client& nats,
            ores::database::context ctx,
            std::string_view name,
            const std::string& jwt_private_key,
            RegisterFn&& register_fn,           // (nats, ctx, signer)
            std::function<void(boost::asio::io_context&)> on_started  = {},
            std::function<void()>                          on_shutdown = {});

signing_service_runner_impl.hpp replaces lines 70-85 of domain_service_runner_impl.hpp (JWKS fetch with backoff) with:

auto signer = ores::security::jwt::jwt_authenticator::create_rs256_signer(
    jwt_private_key);

All other steps — signal setup, register_fn call, on_started, signal wait, on_shutdown, drain, shutdown log — are identical to the domain runner.

Wt's WServer::waitForShutdown() is a blocking call that owns signal handling; it cannot be replaced by the ASIO signal wait inside domain_service_runner. The wt_service_runner is therefore a regular (non-coroutine) function that wraps Wt's blocking lifecycle symmetrically around the NATS infrastructure.

Lifecycle:

1. Connect NATS (synchronous)
2. Run NATS io_context on background thread
3. Fetch JWKS via co_spawn on background io_context; block main thread until
   available (or signal cancels)
4. Create RS256 verifier
5. Call register_fn(nats, ctx, verifier)
6. Spawn heartbeat_publisher on background io_context
7. --- hand off to Wt ---
8. server.start()
9. WServer::waitForShutdown()   ← Wt owns signals from here
10. server.stop()
11. --- return from Wt ---
12. Stop background io_context thread
13. nats.drain()

The background io_context thread runs throughout the Wt server lifetime, keeping the heartbeat coroutine alive. NATS subscriptions registered in step 5 are also serviced on this thread.

// wt_service_runner.hpp
template<typename RegisterFn, typename WtSetupFn>
void run_wt(
    ores::nats::service::client& nats,
    ores::database::context ctx,
    std::string_view name,
    RegisterFn&& register_fn,    // (nats, ctx, verifier)
    WtSetupFn&&  wt_setup_fn);   // sets up and runs WServer; blocks until shutdown

The wt_setup_fn receives no arguments; it closes over the Wt server and argv constructed in main.cpp before the call.

File: projects/ores.iam.service/src/app/application.cpp (lines 54–84)

Replace the hand-rolled lifecycle with run_signing(). The existing signer construction and handler registration become the register_fn lambda. Add the heartbeat_publisher co-spawn in on_started. Remove the manual boost::asio::signal_set and nats.drain().

co_await ores::service::service::run_signing(
    io_ctx, nats, make_context(cfg.database), service_name,
    cfg.jwt_private_key,
    [](auto& n, auto c, auto s) {
        return ores::iam::messaging::registrar::register_handlers(
            n, std::move(c), std::move(s));
    },
    [&nats](boost::asio::io_context& ioc) {
        auto hb = std::make_shared<
            ores::service::service::heartbeat_publisher>(
            std::string(service_name), std::string(service_version), nats);
        boost::asio::co_spawn(ioc,
            [hb]() { return hb->run(); },
            boost::asio::detached);
    });

The registrar signature is unchanged (it already takes a signer).

File: projects/ores.http.server/src/app/application.cpp (lines 53–206)

Replace the hand-rolled lifecycle with domain_service_runner::run().

• The database context, NATS connect, and service-discovery handler registration move into application::run() before calling the runner.
• register_fn calls http_server::messaging::registrar::register_handlers() (NATS discovery + any future NATS subjects); receives verifier for future use.
• on_started spawns heartbeat_publisher and co_spawns the HTTP server coroutine (co_await server.run() becomes a detached co_spawn).
• on_shutdown calls server.stop() and event_source.stop(); these are captured by reference in the lambda.
• Remove the manual boost::asio::signal_set at lines 191–195.

The HTTP routes, event bus, session and system-settings setup remain inside application::run() before the runner call, constructed on the stack and captured by reference in the lambdas.

Files: projects/ores.wt.service/src/main.cpp, projects/ores.wt.service/include/ores.wt.service/config/options.hpp

1. Add nats: nats_options to options.hpp (no database change needed; DB is already there).
2. Add NATS config parsing to config/parser.cpp.
3. In main.cpp, construct nats::service::client before setting up Wt.
4. Replace the server.start() / WServer::waitForShutdown() block with a run_wt() call:

ores::nats::service::client nats(opts.nats);
nats.connect();
ores::service::service::run_wt(
    nats, make_context(opts.database), "ores.wt.service",
    [](auto& n, auto c, auto v) {
        return ores::wt::messaging::registrar::register_handlers(n, c, v);
    },
    [&]() {
        boost_log_sink wt_sink;
        Wt::WServer server(/* ... argv ... */);
        server.setCustomLogger(wt_sink);
        server.addEntryPoint(Wt::EntryPointType::Application,
            &create_application);
        if (server.start()) {
            BOOST_LOG_SEV(lg, info) << "Service ready.";
            Wt::WServer::waitForShutdown();
            server.stop();
        }
    });

A new minimal ores.wt.service/messaging/registrar is introduced (initially empty subscriptions; populated as Wt transitions to NATS calls in future work).

The existing application_context singleton and eventing setup remain unchanged for now.

Files: projects/ores.compute.wrapper/src/app/application.cpp, projects/ores.compute.wrapper/include/ores.compute.wrapper/config/options.hpp

Use the no-database overload of domain_service_runner::run().

• register_fn (signature: nats, verifier) registers the JetStream work queue subscription and result reply handler.
• on_started spawns:
  1. heartbeat_publisher with subject telemetry.v1.services.heartbeat (replaces the custom heartbeat on compute.v1.heartbeat).
  2. node_stats_reporter on its existing compute.v1.telemetry.node_samples subject (unaffected — this is compute-node metrics, not service health).
• on_shutdown stops the work queue and stats reporter cleanly.
• Remove the hand-rolled signal handling and the custom heartbeat loop.

The heartbeat_interval_seconds config field is removed; the standard 15 s default from heartbeat_publisher is used. telemetry_interval_seconds stays (it drives node_stats_reporter).