C++ Coro lifecycle — Startup and Graceful Shutdown

Awaitable initialization and shutdown on one Coro runtime, with a shared shutdown deadline.

When to use

Use this page when implementing maker hooks, owning resources, or diagnosing startup and shutdown.

Generated main creates CoroRuntime, then awaits service.start on its executor.
Function makers in the same initializer group run concurrently; initializer groups are ordered.
The selected epoll or io_uring backend serves the same generated business interfaces.
The main thread observes process signals independently from business workers and starts the shutdown deadline once.
Shutdown awaits service.stop with that deadline and service.waitStopped before releasing service ownership, flushing telemetry and joining runtime workers.

Constraints

Runtime Components in this lifecycle reference are managed resources with startup/shutdown hooks. They are not the Designer visual components: repeated graph fragments stay as separate streams and do not acquire their own maker, start, stop, or invocation counter.
Makers must finish before endpoint admission opens.
A maker failure aborts startup and rolls back resources that already started.
shutdownTimeout is one shared deadline, not a fresh timeout for each phase.
The deadline requests cancellation and records timeout failures; user callbacks and custom resources must cooperate. An in-process runtime cannot safely force-kill arbitrary user code.
A coroutine does not make blocking user code nonblocking; blocking work must not occupy an I/O worker indefinitely.
The generated process watchdog enforces shutdownTimeout even if a handler or destructor does not finish. At the deadline, process exit may bypass remaining cleanup.
The upstream gRPC timer thread, optional Kafka/configuration threads and the blocking executor are accounted for separately from the HTTP/gRPC worker pool.

Start one deadline on signal or startup failure.
Stop configuration reload and await service.stop(context.withDeadline(deadline)).
Await waitStopped while accepted operations retain their required objects.
Release the service, flush telemetry, then stop and join runtime workers.
The process watchdog bounds all phases, including destruction; it is not a fresh timeout for each component.

Generated extension points and runtime-owned lifecycle boundaries.

PropertyTypeDescription

MakeNamecoroutine factory

Returns awaitable<unique_ptr<Name>> with context and environment.

startawaitable lifecycle

Activates the generated service.

stop(context)awaitable lifecycle

Stops using the supplied shared deadline.

waitStoppedawaitable lifecycle

Waits for retained shutdown work before normal ownership release.

ArmShutdownDeadlinegenerated process policy

Forces process exit if graceful shutdown exceeds its total budget.

configure -> make once -> bind -> start -> admit -> drain -> stop