use std::net::SocketAddr;
use std::path::PathBuf;
use tokio::net::TcpListener;
use tokio::sync::oneshot;
use tokio::task::JoinHandle;
mod aws_event_stream;
mod handlers;
mod replacer;
#[doc(hidden)]
pub mod config;
#[doc(hidden)]
pub mod provider;
#[doc(hidden)]
pub mod server;
#[doc(hidden)]
pub mod internal {
pub use crate::config;
pub use crate::provider;
pub use crate::server;
}
#[derive(Debug)]
#[non_exhaustive]
pub enum Error {
InvalidAddress { addr: String, source: std::io::Error },
Bind { addr: String, source: std::io::Error },
Config(String),
Runtime(String),
}
impl std::fmt::Display for Error {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Error::InvalidAddress { addr, source } => {
write!(f, "invalid bind address '{}': {}", addr, source)
}
Error::Bind { addr, source } => {
write!(f, "failed to bind {}: {} (is the port already in use?)", addr, source)
}
Error::Config(msg) => write!(f, "configuration error: {}", msg),
Error::Runtime(msg) => write!(f, "server runtime error: {}", msg),
}
}
}
impl std::error::Error for Error {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Error::InvalidAddress { source, .. } | Error::Bind { source, .. } => Some(source),
_ => None,
}
}
}
pub struct MockServerBuilder {
bind: String,
config_dir: PathBuf,
isolated: bool,
latency_ms: Option<u64>,
mode: Option<String>,
}
impl MockServerBuilder {
fn new() -> Self {
Self {
bind: "127.0.0.1:0".to_string(),
config_dir: PathBuf::from("config"),
isolated: false,
latency_ms: None,
mode: None,
}
}
pub fn bind(mut self, addr: impl Into<String>) -> Self {
self.bind = addr.into();
self
}
pub fn config_dir(mut self, dir: impl Into<PathBuf>) -> Self {
self.config_dir = dir.into();
self
}
pub fn isolated(mut self, isolated: bool) -> Self {
self.isolated = isolated;
self
}
pub fn latency_ms(mut self, ms: u64) -> Self {
self.latency_ms = Some(ms);
self
}
pub fn mode(mut self, mode: impl Into<String>) -> Self {
self.mode = Some(mode.into());
self
}
pub async fn start(self) -> Result<MockServer, Error> {
let listener = TcpListener::bind(&self.bind).await.map_err(|e| {
match e.kind() {
std::io::ErrorKind::InvalidInput | std::io::ErrorKind::AddrNotAvailable => {
Error::InvalidAddress { addr: self.bind.clone(), source: e }
}
_ => Error::Bind { addr: self.bind.clone(), source: e },
}
})?;
let addr = listener
.local_addr()
.map_err(|e| Error::Bind { addr: self.bind.clone(), source: e })?;
let mut config = config::AppConfig::for_embedded(&self.config_dir, self.isolated)
.map_err(|e| Error::Config(e.to_string()))?;
config.port = addr.port();
config.host = addr.ip().to_string();
if let Some(ms) = self.latency_ms {
config.latency.base_ms = ms;
}
if let Some(mode) = &self.mode {
config.latency.mode = mode.clone();
}
let registry = provider::init_registry_with_options(&self.config_dir, self.isolated);
let app = server::create_app(config, None, registry).await;
let (shutdown_tx, shutdown_rx) = oneshot::channel::<()>();
let handle = tokio::spawn(async move {
let _ = axum::serve(listener, app)
.with_graceful_shutdown(async {
let _ = shutdown_rx.await;
})
.await;
});
Ok(MockServer {
addr,
shutdown: Some(shutdown_tx),
handle: Some(handle),
})
}
}
pub struct MockServer {
addr: SocketAddr,
shutdown: Option<oneshot::Sender<()>>,
handle: Option<JoinHandle<()>>,
}
impl MockServer {
pub fn builder() -> MockServerBuilder {
MockServerBuilder::new()
}
pub fn addr(&self) -> SocketAddr {
self.addr
}
pub fn base_url(&self) -> String {
format!("http://{}", self.addr)
}
pub async fn shutdown(mut self) -> Result<(), Error> {
if let Some(tx) = self.shutdown.take() {
let _ = tx.send(());
}
if let Some(handle) = self.handle.take() {
handle.await.map_err(|e| Error::Runtime(e.to_string()))?;
}
Ok(())
}
}
impl Drop for MockServer {
fn drop(&mut self) {
if let Some(tx) = self.shutdown.take() {
let _ = tx.send(());
}
if let Some(handle) = self.handle.take() {
handle.abort();
}
}
}
impl std::fmt::Debug for MockServer {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("MockServer").field("addr", &self.addr).finish()
}
}