add level logging and client implementation for relay communication

Author: ronakgh97

src/client.rs

@@ -0,0 +1,142 @@
+use tokio::io::{BufReader, BufWriter};
+use tokio::net::TcpStream;
+
+use crate::protocol;
+use crate::types::{ClientWire, ServerEvent, ServerWire, SyncError};
+
+/// A connected relay client.
+pub struct Client {
+    reader: BufReader<tokio::net::tcp::OwnedReadHalf>,
+    writer: BufWriter<tokio::net::tcp::OwnedWriteHalf>,
+    max_payload: usize,
+}
+
+impl Client {
+    /// Connect to a relay server.
+    pub async fn connect(addr: &str) -> Result<Self, SyncError> {
+        Self::builder().connect(addr).await
+    }
+
+    /// Start building a client.
+    pub fn builder() -> ClientBuilder {
+        ClientBuilder::new()
+    }
+
+    /// Join a room. If room does not exist, returns [`SyncError::RoomNotFound`]
+    pub async fn join(&mut self, room_id: &str) -> Result<(), SyncError> {
+        let msg = ClientWire::JoinRoom {
+            room_id: room_id.into(),
+        };
+        self.send(&msg).await
+    }
+
+    /// Leave the current room.
+    pub async fn leave(&mut self) -> Result<(), SyncError> {
+        self.send(&ClientWire::LeaveRoom).await
+    }
+
+    /// Send a ping (keep-alive).
+    pub async fn ping(&mut self) -> Result<(), SyncError> {
+        self.send(&ClientWire::Ping).await
+    }
+
+    /// Broadcast raw bytes to all peers in the current room.
+    pub async fn broadcast(&mut self, data: &[u8]) -> Result<(), SyncError> {
+        let msg = ClientWire::Broadcast {
+            data: data.to_vec(),
+        };
+        self.send(&msg).await
+    }
+
+    /// Receive the next server event.
+    /// Ping/pong keepalive is handled internally — the user never sees it.
+    /// Returns `Ok(None)` on clean disconnect.
+    pub async fn recv(&mut self) -> Result<Option<ServerEvent>, SyncError> {
+        loop {
+            let payload = match protocol::read_frame_raw(&mut self.reader, self.max_payload).await {
+                Ok(p) => p,
+                Err(ref e) if e.is_connection_closed() => {
+                    return Ok(None);
+                }
+                Err(e) => return Err(e),
+            };
+
+            let wire: ServerWire = wincode::deserialize(&payload)
+                .map_err(|e| SyncError::Protocol(format!("deserialize failed: {:?}", e)))?;
+
+            // Internal: auto-respond to server pings
+            if matches!(wire, ServerWire::Ping) {
+                self.send(&ClientWire::Pong).await?;
+                continue;
+            }
+
+            // Internal: swallow pong responses
+            if matches!(wire, ServerWire::Pong) {
+                continue;
+            }
+
+            return Ok(Some(Self::wire_to_event(wire)));
+        }
+    }
+
+    async fn send(&mut self, msg: &ClientWire) -> Result<(), SyncError> {
+        protocol::write_frame(&mut self.writer, msg).await
+    }
+
+    fn wire_to_event(wire: ServerWire) -> ServerEvent {
+        match wire {
+            ServerWire::Joined { client_id, room_id } => ServerEvent::Joined { client_id, room_id },
+            ServerWire::PlayerJoined { client_id } => ServerEvent::PlayerJoined { client_id },
+            ServerWire::PlayerLeft { client_id } => ServerEvent::PlayerLeft { client_id },
+            ServerWire::Error(msg) => ServerEvent::Error(msg),
+            ServerWire::Broadcast { sender_id, data } => ServerEvent::Broadcast { sender_id, data },
+            // Ping/Pong are handled internally before reaching here
+            _ => unreachable!("ping/pong should be handled in recv()"),
+        }
+    }
+}
+
+/// Builder for configuring a [`Client`].
+pub struct ClientBuilder {
+    max_payload: usize,
+}
+
+impl ClientBuilder {
+    pub fn new() -> Self {
+        Self {
+            max_payload: 64 * 1024,
+        }
+    }
+}
+
+impl Default for ClientBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ClientBuilder {
+    /// Set max payload size for incoming frames.
+    pub fn max_payload(mut self, n: usize) -> Self {
+        self.max_payload = n;
+        self
+    }
+
+    /// Connect to the server.
+    pub async fn connect(self, addr: &str) -> Result<Client, SyncError> {
+        let stream = TcpStream::connect(addr).await.map_err(|e| {
+            if e.kind() == std::io::ErrorKind::ConnectionRefused {
+                SyncError::ConnectionRefused
+            } else {
+                SyncError::Io(e)
+            }
+        })?;
+        let (read_half, write_half) = stream.into_split();
+
+        Ok(Client {
+            reader: BufReader::new(read_half),
+            writer: BufWriter::new(write_half),
+            max_payload: self.max_payload,
+        })
+    }
+}

src/log.rs

@@ -0,0 +1,106 @@
+use colored::{ColoredString, Colorize};
+use std::env;
+use std::sync::LazyLock;
+
+static GHOSTSYNC_LOG_LEVEL: LazyLock<Level> = LazyLock::new(Level::from_env);
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub enum Level {
+    Trace = 0,
+    Debug = 1,
+    Info = 2,
+    Warn = 3,
+    Error = 4,
+}
+
+impl Level {
+    fn from_env() -> Self {
+        dotenv::dotenv().ok();
+
+        env::var("LOG_LEVEL")
+            .ok()
+            .and_then(|s| match s.to_lowercase().as_str() {
+                "trace" => Some(Level::Trace),
+                "debug" => Some(Level::Debug),
+                "info" => Some(Level::Info),
+                "warn" => Some(Level::Warn),
+                "error" => Some(Level::Error),
+                _ => None,
+            })
+            .unwrap_or(Level::Info)
+    }
+}
+
+#[inline]
+fn should_log(level: Level) -> bool {
+    level >= *GHOSTSYNC_LOG_LEVEL
+}
+
+#[inline]
+pub fn log(level: Level, msg: ColoredString) {
+    if !should_log(level) {
+        return;
+    }
+
+    let now = chrono::Local::now();
+
+    let level_str = match level {
+        Level::Trace => "TRACE".dimmed(),
+        Level::Debug => "DEBUG".blue().bold(),
+        Level::Info => "INFO".green().bold(),
+        Level::Warn => "WARN".yellow().bold(),
+        Level::Error => "ERROR".red().bold(),
+    };
+
+    println!("[{}][{}] {}", now.format("%H:%M:%S"), level_str, msg);
+}
+
+#[macro_export]
+macro_rules! trace {
+    ($($arg:tt)*) => {
+        {
+            use colored::Colorize;
+            $crate::log::log($crate::log::Level::Trace, format!($($arg)*).dimmed())
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! debug {
+    ($($arg:tt)*) => {
+        {
+            use colored::Colorize;
+            $crate::log::log($crate::log::Level::Debug, format!($($arg)*).blue())
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! info {
+    ($($arg:tt)*) => {
+        {
+            use colored::Colorize;
+            $crate::log::log($crate::log::Level::Info, format!($($arg)*).green())
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! warn {
+    ($($arg:tt)*) => {
+        {
+            use colored::Colorize;
+            $crate::log::log($crate::log::Level::Warn, format!($($arg)*).yellow())
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! error {
+    ($($arg:tt)*) => {
+        {
+            use colored::Colorize;
+            $crate::log::log($crate::log::Level::Error, format!($($arg)*).red())
+        }
+    };
+}