Add servercom library to make building voltlane servers easier

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-members = ["connserver", "enc", "net", "clientcom", "clientcom-c"]
+members = ["connserver", "enc", "net", "clientcom", "clientcom-c", "servercom"]
 resolver = "2"
 
 [profile.release-with-debug]

connserver/Cargo.toml

@@ -14,7 +14,6 @@ enc = { path = "../enc" }
 anyhow = "1.0.98"
 serde = { version = "1.0.219", features = ["derive"] }
 toml = "0.8.20"
-async-trait = "0.1.88"
 dotenvy = "0.15.7"
 
 [profile.release-with-debug]

connserver/src/master.rs

@@ -1,15 +1,16 @@
+use std::future::Future;
+
 use net::TaggedPacket;
 use tokio::net::{
     tcp::{OwnedReadHalf, OwnedWriteHalf},
     TcpStream,
 };
 
-#[async_trait::async_trait]
 pub trait MasterDuplex: Send + Sync {
     /// Send a tagged packet to the master.
-    async fn send_packet(&mut self, packet: TaggedPacket) -> anyhow::Result<()>;
+    fn send_packet(&mut self, packet: TaggedPacket) -> impl Future<Output = anyhow::Result<()>> + Send;
     /// Receive a tagged packet from the master.
-    async fn recv_packet(&mut self) -> anyhow::Result<TaggedPacket>;
+    fn recv_packet(&mut self) -> impl Future<Output = anyhow::Result<TaggedPacket>> + Send;
 }
 
 pub struct TcpMasterDuplex {
@@ -29,7 +30,6 @@ impl TcpMasterDuplex {
     }
 }
 
-#[async_trait::async_trait]
 impl MasterDuplex for TcpMasterDuplex {
     async fn send_packet(&mut self, packet: TaggedPacket) -> anyhow::Result<()> {
         net::send_tagged_packet(&mut self.write, packet).await

servercom/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "servercom"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+anyhow = "1.0.98"
+async-trait = "0.1.88"
+net = { path = "../net" }
+thiserror = "2.0.12"
+tokio = "1.44.2"

servercom/src/lib.rs

@@ -0,0 +1,50 @@
+use tokio::net::TcpStream;
+use tokio::net::tcp::{OwnedReadHalf, OwnedWriteHalf};
+use std::future::Future;
+use net;
+
+pub trait MasterServer {
+    fn handle_packet(
+        &mut self,
+        packet: net::TaggedPacket,
+        send_packet: impl AsyncFnMut(net::TaggedPacket) -> anyhow::Result<()>,
+    ) -> impl Future<Output = anyhow::Result<()>>;
+}
+
+pub struct ServerCore<Client, Master>
+where
+    Master: MasterServer,
+{
+    pub clients: Vec<Client>,
+    pub read: net::FramedReader<OwnedReadHalf>,
+    pub write: OwnedWriteHalf,
+    pub master: Master,
+}
+
+impl<ClientT, Master> ServerCore<ClientT, Master>
+where
+    Master: MasterServer,
+{
+    pub fn new(mut stream: TcpStream, master: Master) -> anyhow::Result<Self> {
+        net::configure_performance_tcp_socket(&mut stream)?;
+        let (read, write) = stream.into_split();
+        let read = net::new_framed_reader(read);
+        Ok(Self {
+            read,
+            write,
+            clients: Vec::new(),
+            master,
+        })
+    }
+
+    pub async fn run(&mut self) -> anyhow::Result<()> {
+        loop {
+            let packet = net::recv_tagged_packet(&mut self.read).await?;
+            self.master
+                .handle_packet(packet, async |packet| -> anyhow::Result<()> {
+                    net::send_tagged_packet(&mut self.write, packet).await
+                })
+                .await?;
+        }
+    }
+}