use std::future::Future;
use std::net::{Ipv4Addr, SocketAddr};
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Arc;
use std::time::{Duration, Instant};
use http_body_util::{BodyExt, Full};
use hyper::body::{Bytes, Incoming};
use hyper::{Request, Response, StatusCode};
use rmcp::transport::streamable_http_server::session::local::LocalSessionManager;
use rmcp::transport::StreamableHttpService;
use tokio_util::sync::CancellationToken;
use crate::mcp::MemforkServer;
use crate::persist::{Endpoint, Store};
use crate::tools::dispatch::Session;
pub const MCP_PATH: &str = "/mcp";
pub const SHUTDOWN_PATH: &str = "/shutdown";
pub const DEFAULT_IDLE_SECONDS: u64 = 600;
#[derive(Debug, Clone)]
pub struct ServeOptions {
pub port: u16,
pub idle_seconds: u64,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Stopped {
Idle,
Asked,
Failed,
}
#[derive(Debug)]
struct Clock {
last_seen: AtomicU64,
started: Instant,
}
impl Clock {
fn new() -> Self {
Clock {
last_seen: AtomicU64::new(0),
started: Instant::now(),
}
}
fn touch(&self) {
let elapsed = self.started.elapsed().as_millis() as u64;
self.last_seen.store(elapsed, Ordering::Relaxed);
}
fn idle_for(&self) -> Duration {
let now = self.started.elapsed().as_millis() as u64;
Duration::from_millis(now.saturating_sub(self.last_seen.load(Ordering::Relaxed)))
}
}
pub async fn run(
db: memfork_core::Db,
store: Arc<Store>,
options: ServeOptions,
) -> Result<Stopped, String> {
let token = crate::persist::lock::new_token().map_err(|e| e.to_string())?;
let listener =
tokio::net::TcpListener::bind(SocketAddr::from((Ipv4Addr::LOCALHOST, options.port)))
.await
.map_err(|e| format!("cannot listen on 127.0.0.1:{}: {e}", options.port))?;
let port = listener
.local_addr()
.map_err(|e| format!("cannot read the port that was bound: {e}"))?
.port();
let mut endpoint = Endpoint::for_this_process();
endpoint.port = Some(port);
endpoint.token = Some(token.clone());
store.publish(&endpoint).map_err(|e| e.to_string())?;
let shutdown = CancellationToken::new();
let clock = Arc::new(Clock::new());
clock.touch();
let shared = db.clone();
let service = StreamableHttpService::new(
move || Ok(MemforkServer::new(Arc::new(Session::new(shared.clone())))),
Arc::new(LocalSessionManager::default()),
rmcp::transport::streamable_http_server::StreamableHttpServerConfig::default()
.with_json_response(true)
.with_legacy_session_mode(true),
);
let idle = {
let clock = Arc::clone(&clock);
let shutdown = shutdown.clone();
let limit = options.idle_seconds;
tokio::spawn(async move {
if limit == 0 {
return false;
}
let limit = Duration::from_secs(limit);
loop {
tokio::select! {
_ = shutdown.cancelled() => return false,
_ = tokio::time::sleep(Duration::from_millis(250)) => {
if clock.idle_for() >= limit {
shutdown.cancel();
return true;
}
}
}
}
})
};
let accept = {
let shutdown = shutdown.clone();
let clock = Arc::clone(&clock);
let token = token.clone();
async move {
loop {
let stream = tokio::select! {
_ = shutdown.cancelled() => break,
accepted = listener.accept() => match accepted {
Ok((stream, _)) => stream,
Err(_) => continue,
},
};
let service = service.clone();
let shutdown = shutdown.clone();
let clock = Arc::clone(&clock);
let token = token.clone();
tokio::spawn(async move {
let guard = Guard {
inner: service,
token,
clock,
shutdown,
};
let io = hyper_util::rt::TokioIo::new(stream);
let _ = hyper::server::conn::http1::Builder::new()
.serve_connection(io, hyper_util::service::TowerToHyperService::new(guard))
.await;
});
}
}
};
accept.await;
let stopped = if idle.await.unwrap_or(false) {
Stopped::Idle
} else {
Stopped::Asked
};
store.flush().map_err(|e| e.to_string())?;
Ok(stopped)
}
#[derive(Clone)]
struct Guard {
inner: StreamableHttpService<MemforkServer, LocalSessionManager>,
token: String,
clock: Arc<Clock>,
shutdown: CancellationToken,
}
type BoxBody = http_body_util::combinators::BoxBody<Bytes, std::io::Error>;
fn text(status: StatusCode, message: &str) -> Response<BoxBody> {
let body = Full::new(Bytes::from(message.to_owned()))
.map_err(|never| match never {})
.boxed();
Response::builder()
.status(status)
.header("content-type", "text/plain; charset=utf-8")
.body(body)
.unwrap_or_else(|_| Response::new(BoxBody::default()))
}
impl tower_service::Service<Request<Incoming>> for Guard {
type Response = Response<BoxBody>;
type Error = std::convert::Infallible;
type Future = std::pin::Pin<
Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send + 'static>,
>;
fn poll_ready(
&mut self,
_cx: &mut std::task::Context<'_>,
) -> std::task::Poll<Result<(), Self::Error>> {
std::task::Poll::Ready(Ok(()))
}
fn call(&mut self, request: Request<Incoming>) -> Self::Future {
self.clock.touch();
let presented = request
.headers()
.get(hyper::header::AUTHORIZATION)
.and_then(|v| v.to_str().ok())
.and_then(|v| v.strip_prefix("Bearer "))
.unwrap_or_default()
.to_owned();
let authorized = presented.len() == self.token.len()
&& presented
.bytes()
.zip(self.token.bytes())
.fold(0u8, |acc, (a, b)| acc | (a ^ b))
== 0;
if !authorized {
return Box::pin(async {
Ok(text(
StatusCode::UNAUTHORIZED,
"this MemFork daemon needs the token from its endpoint file\n",
))
});
}
if request.uri().path() == SHUTDOWN_PATH {
self.shutdown.cancel();
return Box::pin(async { Ok(text(StatusCode::OK, "stopping\n")) });
}
let mut inner = self.inner.clone();
Box::pin(async move {
match tower_service::Service::call(&mut inner, request).await {
Ok(response) => Ok(response.map(|b| b.map_err(std::io::Error::other).boxed())),
Err(never) => match never {},
}
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_idle_clock_measures_from_the_last_request() {
let clock = Clock::new();
clock.touch();
assert!(clock.idle_for() < Duration::from_millis(100));
}
const _: () = {
assert!(DEFAULT_IDLE_SECONDS >= 300);
assert!(DEFAULT_IDLE_SECONDS <= 3600);
};
}