Struct Server 

pub struct Server {
    pub name: OwnedServerName,
    pub config: Manager,
    pub config_sources: Sources,
    pub started: SystemTime,
    pub stopping: AtomicBool,
    pub reloading: AtomicBool,
    pub restarting: AtomicBool,
    pub backup_restored: AtomicBool,
    pub runtime: Option<Handle>,
    pub signal: Sender<&'static str>,
    pub log: Logging,
    pub metrics: Arc<Metrics>,
}

Server runtime state; public portion

Fields

name: OwnedServerName

Configured name of server. This is the same as the one in the config but developers can (and should) reference this string instead.

config: Manager

Server-wide configuration instance

config_sources: Sources

Where the configuration came from, replayed on reload.

started: SystemTime

Timestamp server was started; used for uptime.

stopping: AtomicBool

Reload/shutdown pending indicator; server is shutting down. This is an observable used on shutdown and should not be modified.

reloading: AtomicBool

Reload/shutdown desired indicator; when false, shutdown is desired. This is an observable used on shutdown and modifying is not recommended.

restarting: AtomicBool

Restart desired; when true, restart it desired after shutdown.

backup_restored: AtomicBool

Set when a backup restore is claimed, which is before it runs and is not undone if it fails, so a database reopened later in the same process does not restore a second time. Clearing this re-arms a destructive operation and is never correct; claim it instead.

runtime: Option<Handle>

Handle to the runtime

signal: Sender<&'static str>

Reload/shutdown signal

log: Logging

Logging subsystem state

metrics: Arc<Metrics>

Metrics subsystem state

Implementations

impl Server

pub fn new( config: Config, config_sources: Sources, runtime: Option<&Handle>, log: Logging, metrics: Arc<Metrics>, ) -> Self

Creates shared server lifecycle state.

The initial configuration, source list, logging state, and metrics become available to all services. A supplied runtime handle enables task spawning.

pub fn reload(&self) -> Result

Requests a dynamic module reload.

The request marks the server as reloading and stopping before broadcasting SIGINT. Concurrent reload or shutdown requests are rejected.

pub fn restart(&self) -> Result

Requests a process restart through the normal shutdown path.

The restarting flag is claimed once before shutdown begins. A rejected shutdown clears that flag so a later request may retry.

pub fn shutdown(&self) -> Result

Requests an orderly server shutdown.

The stopping flag is claimed once before broadcasting SIGTERM. A second request is rejected while shutdown remains in progress.

pub fn claim_backup_restore(&self) -> bool

Claims the one-shot backup restore, reporting whether this caller is the one to perform it.

pub fn signal(&self, sig: &'static str) -> Result

Broadcasts a process-signal name to lifecycle subscribers.

Delivery is best effort because subscribers may not yet be listening. The method therefore succeeds even when the channel has no receivers.

pub async fn until_shutdown(self: &Arc<Self>)

Waits until the server enters its stopping state.

Lifecycle notifications wake the loop so it can recheck the shared state. Calling it after shutdown has begun returns immediately.

pub fn runtime(&self) -> &Handle

Returns the runtime handle supplied during server construction.

Services use this handle to spawn work on the embedding runtime. The handle is borrowed for the lifetime of the server.

Panics

Panics when the server was constructed without a runtime handle.

pub fn check_running(&self) -> Result

Rejects new work after shutdown begins.

A running server returns success. A stopping server returns an interrupted I/O error wrapped in the shared error type.

pub fn is_running(&self) -> bool

Reports whether the server still accepts work.

Running is the inverse of the stopping state. Reload and restart requests also transition the server through stopping.

pub fn is_stopping(&self) -> bool

Reports whether shutdown has begun.

The flag is set by shutdown and reload transitions. Reads are relaxed because callers use it as a lifecycle observation rather than a synchronization edge.

pub fn is_reloading(&self) -> bool

Reports whether a dynamic module reload is in progress.

Reload claims the flag before checking the stopping state. Signal-delivery failure clears it, while rejection by an existing shutdown can leave it set.

pub fn is_restarting(&self) -> bool

Reports whether a process restart is in progress.

Restart claims the flag before requesting shutdown. Failed shutdown initiation clears it for a later attempt.

pub fn is_ours(&self, name: &str) -> bool

Reports whether a name matches the configured local server name.

The comparison uses the active configuration snapshot. It performs an exact, case-sensitive string comparison.