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::cli::Command;
use crate::events::{Event, Events};
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 EVENTS_PATH: &str = "/events";
pub const CLI_PATH: &str = "/cli";
pub const CLI_WRITER: &str = "memfork-cli";
pub const DEFAULT_SESSION_SECONDS: u64 = 1800;
pub const DEFAULT_IDLE_SECONDS: u64 = 600;
#[derive(Debug, Clone)]
pub struct ServeOptions {
pub port: u16,
pub idle_seconds: u64,
pub session_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 events = Arc::new(Events::default());
let shared = db.clone();
let hub = Arc::clone(&events);
let mut sessions = LocalSessionManager::default();
sessions.session_config.keep_alive = Some(Duration::from_secs(options.session_seconds.max(1)));
let service = StreamableHttpService::new(
move || {
Ok(MemforkServer::new(Arc::new(
Session::new(shared.clone()).reporting_to(Arc::clone(&hub)),
)))
},
Arc::new(sessions),
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();
let events = Arc::clone(&events);
let db = db.clone();
tokio::spawn(async move {
let guard = Guard {
inner: service,
token,
clock,
shutdown,
events,
db,
port,
};
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,
events: Arc<Events>,
db: memfork_core::Db,
port: u16,
}
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 {
if request.uri().path() != EVENTS_PATH {
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")) });
}
if request.uri().path() == EVENTS_PATH {
return Box::pin(std::future::ready(Ok(event_stream(
&self.events,
self.port,
self.shutdown.clone(),
))));
}
if request.uri().path() == CLI_PATH {
let db = self.db.clone();
let events = Arc::clone(&self.events);
return Box::pin(async move { Ok(run_cli(request, db, events).await) });
}
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 {},
}
})
}
}
fn json_response(status: StatusCode, value: &serde_json::Value) -> Response<BoxBody> {
let body = Full::new(Bytes::from(value.to_string()))
.map_err(|never| match never {})
.boxed();
Response::builder()
.status(status)
.header("content-type", "application/json")
.body(body)
.unwrap_or_else(|_| Response::new(BoxBody::default()))
}
fn event_stream(events: &Events, port: u16, shutdown: CancellationToken) -> Response<BoxBody> {
let hello = crate::events::Hello {
kind: "hello".to_owned(),
version: crate::VERSION.to_owned(),
port,
clients: events.connected(),
};
let first = serde_json::to_string(&hello).unwrap_or_default();
let receiver = events.subscribe();
let stream = futures::stream::unfold(
(Some(first), receiver, shutdown),
|(first, mut receiver, shutdown)| async move {
if let Some(line) = first {
return Some((line, (None, receiver, shutdown)));
}
loop {
tokio::select! {
_ = shutdown.cancelled() => return None,
got = receiver.recv() => match got {
Ok(event) => {
let line = serde_json::to_string(&event).unwrap_or_default();
return Some((line, (None, receiver, shutdown)));
}
Err(tokio::sync::broadcast::error::RecvError::Lagged(_)) => continue,
Err(tokio::sync::broadcast::error::RecvError::Closed) => return None,
},
}
}
},
);
let frames = futures::StreamExt::map(stream, |line| {
Ok::<_, std::io::Error>(hyper::body::Frame::data(Bytes::from(line + "\n")))
});
let body = BodyExt::boxed(http_body_util::StreamBody::new(frames));
Response::builder()
.status(StatusCode::OK)
.header("content-type", "application/x-ndjson")
.header("cache-control", "no-store")
.body(body)
.unwrap_or_else(|_| Response::new(BoxBody::default()))
}
async fn run_cli(
request: Request<Incoming>,
db: memfork_core::Db,
events: Arc<Events>,
) -> Response<BoxBody> {
let bad = |why: String| {
json_response(
StatusCode::BAD_REQUEST,
&serde_json::json!({ "error": why }),
)
};
let bytes = match request.into_body().collect().await {
Ok(collected) => collected.to_bytes(),
Err(e) => return bad(format!("the request could not be read: {e}")),
};
#[derive(serde::Deserialize)]
struct Call {
branch: String,
command: Command,
namespace: Option<String>,
}
let call: Call = match serde_json::from_slice(&bytes) {
Ok(call) => call,
Err(e) => return bad(format!("the request did not parse: {e}")),
};
if !call.command.allowed_in_script() {
return bad(format!(
"`memfork {}` is not an operation on the store",
call.command.name()
));
}
let Call {
branch,
command,
namespace,
} = call;
let (key, target) = crate::exec::target(&command, &branch);
let name = command.name();
let outcome = tokio::task::spawn_blocking(move || {
crate::exec::execute_as(&db, &branch, &command, Some(CLI_WRITER))
})
.await;
let outcome = match outcome {
Ok(outcome) => outcome,
Err(e) => Err(crate::exec::ExecError::Usage(format!(
"the operation did not finish: {e}"
))),
};
events.publish(Event {
operation: Some(name.to_owned()),
key,
branch: target,
ok: outcome.is_ok(),
error: outcome.as_ref().err().map(ToString::to_string),
..Event::about(CLI_WRITER, namespace.as_deref())
});
match outcome {
Ok(outcome) => json_response(
StatusCode::OK,
&serde_json::json!({ "text": outcome.text, "json": outcome.json }),
),
Err(e) => json_response(
StatusCode::UNPROCESSABLE_ENTITY,
&serde_json::json!({ "error": e.to_string() }),
),
}
}
#[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);
};
}