use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::Duration;
use tokio::net::TcpListener;
use super::config::{Config, ConfigError};
use super::handler::Handler;
use super::publisher::{Error, Publisher};
use super::run;
use super::state::{ServerCommand, SharedState};
use crate::cluster::ClusterCommand;
pub struct Server {
shared: Arc<SharedState>,
running: Arc<AtomicBool>,
task: tokio::sync::Mutex<Option<tokio::task::JoinHandle<()>>>,
}
impl Server {
pub fn new(config: Config) -> Result<Self, ConfigError> {
Ok(Self {
shared: Arc::new(config.into_state()?),
running: Arc::new(AtomicBool::new(false)),
task: tokio::sync::Mutex::new(None),
})
}
pub fn publisher(&self) -> Publisher {
Publisher::new(Arc::clone(&self.shared))
}
pub fn start<H: Handler>(&self, listener: TcpListener, handler: H) -> Result<(), Error> {
let Ok(mut task) = self.task.try_lock() else {
return Err(Error::Running);
};
if task.as_ref().is_some_and(|task| !task.is_finished()) {
return Err(Error::Running);
}
let handler = Arc::new(handler);
let started = run::start(&self.shared, &handler);
self.running.store(true, Ordering::SeqCst);
*task = Some(tokio::spawn(run::serve(
Arc::clone(&self.shared),
started,
listener,
handler,
Arc::clone(&self.running),
)));
Ok(())
}
pub fn is_running(&self) -> bool {
self.running.load(Ordering::SeqCst)
}
pub async fn stop(&self) {
let mut task = self.task.lock().await;
let Some(running) = task.take() else {
return;
};
self.shut_down();
let _ = running.await;
run::stopped(&self.shared);
}
fn shut_down(&self) {
if let Some(tx) = self.shared.cluster_cmd_tx.load_full() {
let _ = tx.send(ClusterCommand::Shutdown);
}
let _ = self.publisher().command(ServerCommand::Shutdown);
self.running.store(false, Ordering::SeqCst);
}
pub async fn drain(&self, code: u16, reason: &str, timeout: Duration) -> Result<usize, Error> {
let publisher = self.publisher();
publisher.command(ServerCommand::Drain {
close_code: code,
close_reason: reason.to_owned(),
})?;
let deadline = tokio::time::Instant::now().checked_add(timeout);
loop {
let left = self.shared.connection_count.load(Ordering::Relaxed);
if left == 0 {
return Ok(0);
}
if deadline.is_some_and(|deadline| tokio::time::Instant::now() >= deadline) {
let _ = publisher.command(ServerCommand::AbortAll);
return Ok(left);
}
tokio::time::sleep(Duration::from_millis(50)).await;
}
}
pub fn connection_count(&self) -> usize {
self.shared.connection_count.load(Ordering::Relaxed)
}
}
impl Drop for Server {
fn drop(&mut self) {
if self.task.get_mut().is_some() {
self.shut_down();
}
}
}