Struct Server 

pub struct Server {
    pub state_rx: Receiver<ServingState>,
    /* private fields */
}

Fields

state_rx: Receiver<ServingState>

Implementations

impl Server

pub fn builder() -> ServerBuilder

impl Server

pub fn into_router(self) -> (Routes, JoinHandle<Result<(), ServerError>>)

Return the configured TsoServiceServer<TsoServiceImpl> as a tonic Routes value plus a JoinHandle for the spawned leader-watch task, so callers can mount tsoracle’s service alongside their own services on a shared tonic listener instead of binding a dedicated port.

The JoinHandle payload is Result<(), ServerError> so embedders can observe leader-watch termination. The task never returns Ok(()): every termination — driver error, panic, or clean EOF on the leadership stream (surfaced as ServerError::WatchStreamClosed) — publishes ServingState::NotServing { leader_endpoint: None } before returning, so all subsequent RPCs fail fast with FAILED_PRECONDITION. Embedders who never inspect the handle still get fail-safe behavior.

The Server::serve() method is a thin wrapper over this — it calls into_router, builds a tonic Server, and binds a listener.

pub async fn serve(self, addr: SocketAddr) -> Result<(), ServerError>

pub async fn serve_with_shutdown( self, addr: SocketAddr, shutdown: impl Future<Output = ()> + Send + 'static, ) -> Result<(), ServerError>

Run the gRPC server until either the caller’s shutdown fires or the leader-watch task terminates.

Three outcomes:

1. shutdown fires first → tonic drains in-flights and returns Ok. The watch handle is aborted; any error it had been about to return is forfeited (the process is shutting down anyway).
2. Watch returns Ok(Err(e)) → poisoned state is already published; cancel_tx triggers tonic’s graceful shutdown; in-flight GetTs calls whose try_grant already succeeded complete with the timestamps they were allocated; new calls fail fast. Returns Err(e).
3. Watch task panics → returns Err(ServerError::WatchPanic{..}) with the panic payload stringified. Same drain semantics as (2).

pub async fn serve_with_listener( self, listener: TcpListener, shutdown: impl Future<Output = ()> + Send + 'static, ) -> Result<(), ServerError>

Run the gRPC server on a caller-provided TcpListener until either the caller-provided shutdown fires or the leader-watch task terminates.

Use this instead of Self::serve_with_shutdown when you need to observe the OS-picked port (127.0.0.1:0) before clients connect, or when you want to wrap the listener in an outer adapter before passing it in. The listening socket is owned by the caller and passed here; tsoracle starts accepting on it immediately.

Three outcomes:

1. shutdown fires first → tonic drains in-flights and returns Ok. The watch handle is aborted; any error it had been about to return is forfeited (the process is shutting down anyway).
2. Watch returns Ok(Err(e)) → poisoned state is already published; the caller-provided shutdown is cancelled internally so tonic begins graceful shutdown; in-flight GetTs calls whose try_grant already succeeded complete with the timestamps they were allocated; new calls fail fast. Returns Err(e).
3. Watch task panics → returns Err(ServerError::WatchPanic{..}) with the panic payload stringified. Same drain semantics as (2).