use std::sync::Arc;
use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
use tokio::sync::mpsc;
use crate::conduit::Conduit;
use crate::frame::{self, Frame};
pub const POSTGRES_ADDRESS: &str = "127.0.0.1";
pub const POSTGRES_PORT: u16 = 14979;
pub const HOST_ADDRESS: &str = "0.0.0.0";
pub const HOST_PORT: u16 = 14980;
const READ_CHUNK: usize = 16 * 1024;
pub struct Servers {
pub conduit: Arc<Conduit>,
pub postgres: tokio::net::TcpListener,
pub host: tokio::net::TcpListener,
pub router: axum::Router,
}
pub async fn setup() -> std::io::Result<Servers> {
let conduit = Conduit::new();
let router = axum::Router::new()
.route("/", axum::routing::any(upgrade))
.with_state(Arc::clone(&conduit));
let (postgres, host) = tokio::try_join!(
tokio::net::TcpListener::bind((POSTGRES_ADDRESS, POSTGRES_PORT)),
tokio::net::TcpListener::bind((HOST_ADDRESS, HOST_PORT)),
)?;
Ok(Servers {
conduit,
postgres,
host,
router,
})
}
pub async fn serve(servers: Servers) -> std::io::Result<()> {
let Servers {
conduit,
postgres,
host,
router,
} = servers;
use axum::serve::ListenerExt;
let host = host.tap_io(|io| objectiveai_sdk::net::set_tcp_keepalive(io));
tokio::select! {
result = accept_postgres(postgres, conduit) => result,
result = axum::serve(host, router) => result,
}
}
pub async fn run() -> std::io::Result<()> {
let servers = setup().await?;
tracing::info!(
postgres = %servers.postgres.local_addr()?,
host = %servers.host.local_addr()?,
"listening",
);
serve(servers).await
}
async fn accept_postgres(
listener: tokio::net::TcpListener,
conduit: Arc<Conduit>,
) -> std::io::Result<()> {
loop {
match listener.accept().await {
Ok((stream, _)) => {
tokio::spawn(client(stream, Arc::clone(&conduit)));
}
Err(error) => {
tracing::warn!(%error, "accept failed");
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
}
}
}
}
async fn client(stream: tokio::net::TcpStream, conduit: Arc<Conduit>) {
let _ = stream.set_nodelay(true);
let Some(host) = conduit.host().await else {
return;
};
let (mut read, mut write) = stream.into_split();
let (tx, mut rx) = mpsc::unbounded_channel();
let id = conduit.open(host.epoch, tx);
if host
.tx
.send(axum::extract::ws::Message::Binary(frame::encode_open(id)))
.is_err()
{
conduit.close(id);
return;
}
let writer = tokio::spawn(async move {
while let Some(payload) = rx.recv().await {
if write.write_all(&payload).await.is_err() {
break;
}
}
let _ = write.shutdown().await;
});
let mut buf = vec![0u8; READ_CHUNK];
loop {
let result = tokio::select! {
_ = conduit.detached(host.epoch) => break,
result = read.read(&mut buf) => result,
};
let filled = match result {
Ok(0) | Err(_) => break,
Ok(filled) => filled,
};
if host
.tx
.send(axum::extract::ws::Message::Binary(frame::encode_data(
id,
&buf[..filled],
)))
.is_err()
{
break;
}
}
conduit.close(id);
let _ = host
.tx
.send(axum::extract::ws::Message::Binary(frame::encode_close(id)));
drop(writer);
}
async fn upgrade(
ws: axum::extract::WebSocketUpgrade,
axum::extract::State(conduit): axum::extract::State<Arc<Conduit>>,
) -> axum::response::Response {
ws.on_upgrade(move |socket| relay(socket, conduit))
}
async fn relay(socket: axum::extract::ws::WebSocket, conduit: Arc<Conduit>) {
use axum::extract::ws::Message;
use futures::{SinkExt as _, StreamExt as _};
let (mut sink, mut stream) = socket.split();
let (tx, mut rx) = mpsc::unbounded_channel::<Message>();
let writer = tokio::spawn(async move {
while let Some(message) = rx.recv().await {
if sink.send(message).await.is_err() {
break;
}
}
});
let epoch = conduit.attach(tx);
while let Some(Ok(message)) = stream.next().await {
match message {
Message::Binary(bytes) => {
if let Some(frame) = Frame::decode(bytes) {
conduit.route(frame);
}
}
Message::Close(_) => break,
_ => {}
}
}
conduit.detach(epoch);
writer.abort();
}