refactor networking

1 files changed, 13 insertions, 21 deletions

diff --git a/karld/src/interface/websocket.rs b/karld/src/interface/websocket.rs
index da7d918..624c28c 100644
--- a/karld/src/interface/websocket.rs
+++ b/karld/src/interface/websocket.rs
@@ -1,37 +1,29 @@
-use karlcommon::{ServerboundPacket, ProtoError, ClientboundPacket, version};
-use log::{debug, error, info};
+use crate::handle_packet;
+use crate::interface::generic;
+use crossbeam_channel::{Receiver, Sender};
+use karlcommon::{ClientboundPacket, ProtoError, ServerboundPacket};
+use log::{debug, info};
 use std::net::{TcpListener, TcpStream};
 use std::thread;
 use tungstenite::{accept, Message};
-use crate::{handle_packet, CLIENT_ID_COUNTER};
 
 pub fn run() {
     info!("binding websocket server");
     let server = TcpListener::bind("127.0.0.1:9001").unwrap();
     info!("listening");
-
     for stream in server.incoming() {
-        thread::spawn(move || {
-            if let Err(e) = handle_connection(stream) {
-                error!("{e}");
-            }
-        });
+        thread::spawn(move || generic::handle_connection(handle_connection, stream));
     }
 }
 
-fn handle_connection(stream: Result<TcpStream, std::io::Error>) -> anyhow::Result<()> {
-    let id = CLIENT_ID_COUNTER.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
-    
+fn handle_connection(
+    id: u32,
+    (responder, responses): (Sender<ClientboundPacket>, Receiver<ClientboundPacket>),
+    stream: Result<TcpStream, std::io::Error>,
+) -> anyhow::Result<()> {
     let stream = stream?;
     stream.set_nonblocking(true)?;
     let mut websocket = accept(stream)?;
-    
-    let (responder, responses) = crossbeam_channel::unbounded();
-    responder
-        .send(ClientboundPacket::Handshake {
-            version: version!(),
-        })
-        .unwrap();
 
     loop {
         match websocket.read_message() {
@@ -50,14 +42,14 @@ fn handle_connection(stream: Result<TcpStream, std::io::Error>) -> anyhow::Resul
             Err(tungstenite::Error::ConnectionClosed) => {
                 break Ok(());
             }
-            Err(tungstenite::Error::Io(e)) 
+            Err(tungstenite::Error::Io(e))
                 if let std::io::ErrorKind::WouldBlock = e.kind() => {
                     // its fine
                 }
             Err(e) => Err(e)?,
         }
         for r in responses.try_iter() {
-            websocket.write_message(Message::Text( serde_json::to_string(&r)?))?;
+            websocket.write_message(Message::Text(serde_json::to_string(&r)?))?;
         }
         thread::sleep(std::time::Duration::from_millis(50)); // how would you do this properly??
     }