//! `meowsrv`: Meow v2 relay server. //! //! `meowsrv healthcheck` exits 0 when the local server answers `/healthz` (used by the //! container image, which has no shell nor curl). use std::sync::Arc; use clap::Parser; use meow_server::config::{load_or_create_keys, Args, Config}; use meow_server::store::{MemoryStore, RedisStore, ServerStore}; use meow_server::{encode_card, router, AppState, Limits}; use tokio::sync::broadcast; const MAX_PER_MAILBOX: usize = 10_000; /// `meowsrv healthcheck`: GET /healthz on the local listen port (MEOWSRV_LISTEN). fn healthcheck() -> i32 { use std::io::{Read, Write}; let listen = std::env::var("MEOWSRV_LISTEN").unwrap_or_else(|_| "127.0.0.1:8080".into()); let port = listen.rsplit(':').next().unwrap_or("8080"); let addr = format!("127.0.0.1:{port}"); let Ok(sock) = addr.parse() else { return 2 }; let timeout = std::time::Duration::from_secs(3); let Ok(mut s) = std::net::TcpStream::connect_timeout(&sock, timeout) else { return 1; }; let _ = s.set_read_timeout(Some(timeout)); if s.write_all(b"GET /healthz HTTP/1.0\r\nHost: localhost\r\n\r\n") .is_err() { return 1; } let mut buf = [0u8; 16]; match s.read(&mut buf) { Ok(n) if buf[..n].starts_with(b"HTTP/1.1 200") || buf[..n].starts_with(b"HTTP/1.0 200") => 0, _ => 1, } } /// Ctrl+C or SIGTERM (`docker stop`). async fn shutdown_signal() { #[cfg(unix)] { let mut term = match tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()) { Ok(s) => s, Err(_) => { let _ = tokio::signal::ctrl_c().await; return; } }; tokio::select! { _ = tokio::signal::ctrl_c() => {} _ = term.recv() => {} } } #[cfg(not(unix))] let _ = tokio::signal::ctrl_c().await; tracing::info!("shutting down"); } #[tokio::main] async fn main() -> anyhow::Result<()> { if std::env::args().nth(1).as_deref() == Some("healthcheck") { std::process::exit(healthcheck()); } let cfg = Config::resolve(Args::parse())?; tracing_subscriber::fmt() .with_env_filter(tracing_subscriber::EnvFilter::new(&cfg.log)) .init(); let keys = load_or_create_keys(&cfg.key_file)?; let (notify, _) = broadcast::channel(4096); let store: Arc = if cfg.storage == "memory" { tracing::warn!("using in-memory storage: messages are lost on restart"); Arc::new(MemoryStore::new(notify.clone(), MAX_PER_MAILBOX)) } else { Arc::new(RedisStore::connect(&cfg.storage, notify.clone(), cfg.mailbox_ttl, MAX_PER_MAILBOX).await?) }; let card = encode_card(&keys, &cfg.public_url, &cfg.name, &cfg.description); tracing::info!( url = %cfg.public_url, sign_key = %keys.sign.public().fingerprint(), "server identity" ); let state = Arc::new(AppState { keys, card, store, notify, limits: Limits::default(), }); let listener = tokio::net::TcpListener::bind(&cfg.listen).await?; tracing::info!("listening on {}", cfg.listen); axum::serve(listener, router(state)) .with_graceful_shutdown(shutdown_signal()) .await?; Ok(()) }