Struct ControlServer 

pub struct ControlServer<H>
where
    H: LifecycleHandle + Clone + Send + Sync + 'static,
{ /* private fields */ }

HTTP server that hosts the control plane router.

Generic over H, which must implement lightshuttle_runtime::LifecycleHandle. The handle is held inside a crate::ControlState and shared across all route handlers via axum’s state mechanism.

Usage

1. Call bind to open a listener (loopback only, no authentication).
2. Build a crate::ControlState with the project name and handle.
3. Construct a ControlServer via ControlServer::new.
4. Await ControlServer::serve with a shutdown future.

For in-process integration tests, use ControlServer::into_router to get the raw axum router and drive it with tower::ServiceExt::oneshot without opening a TCP socket.

Implementations

impl<H> ControlServer<H>

where H: LifecycleHandle + Clone + Send + Sync + 'static,

pub fn new(state: ControlState<H>) -> Self

Build a server from the given shared state.

The state holds the project name, the lifecycle handle, and the Prometheus metrics renderer. It is moved into the axum router when ControlServer::serve or ControlServer::into_router is called.

pub fn into_router(self) -> Router

Consume the server and return the underlying axum::Router.

Useful for in-process integration tests: pass the router to tower::ServiceExt::oneshot to send synthetic requests without the overhead of a real TCP bind.

pub async fn serve<F>(self, listener: TcpListener, shutdown: F) -> Result<()>

where F: Future<Output = ()> + Send + 'static,

Run the control plane on listener until shutdown resolves.

Starts accepting connections immediately. When shutdown resolves, axum performs a graceful shutdown: it stops accepting new connections and waits for in-flight requests to complete before returning.

Errors

Propagates any std::io::Error from the underlying TCP accept loop.

Example

use std::net::SocketAddr;
use lightshuttle_control::{ControlState, ControlServer, bind};

let addr: SocketAddr = "127.0.0.1:9090".parse().unwrap();
let listener = bind(addr).await?;
let state = ControlState::new("my-project", MyHandle);
let server = ControlServer::new(state);

// Shutdown when Ctrl-C is received.
server
    .serve(listener, async { tokio::signal::ctrl_c().await.ok(); })
    .await