From 5f01678113531bcc5fd140e293e9446618b89ac0 Mon Sep 17 00:00:00 2001
From: nafissatou <nafisatouhamadou2@gmail.com>
Date: Sat, 5 Apr 2025 20:58:36 +0100
Subject: [PATCH 1/3] Fix connection.rs error and warnings, improve error
 handling

---
 Cargo.toml                   |  5 +++--
 src/bin/server/connection.rs | 30 +++++++++++++++++-------------
 2 files changed, 20 insertions(+), 15 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 8b2a424..f999c21 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "async-chat"
 version = "0.1.0"
-edition = "2024"
+edition = "2021"
 authors = ["Christian yemele <yemelechristian2@gmail.com>"]
 
 [dependencies]
@@ -9,4 +9,5 @@ async-std = { version = "1.7", features = ["unstable"] }
 tokio = { version = "1.0", features = ["sync"] }
 serde = { version = "1.0", features = ["derive", "rc"] }
 serde_json = "1.0"
-anyhow = "1.0.97"
+anyhow = "1.0"
+
diff --git a/src/bin/server/connection.rs b/src/bin/server/connection.rs
index 96deb66..b216e3f 100644
--- a/src/bin/server/connection.rs
+++ b/src/bin/server/connection.rs
@@ -4,15 +4,18 @@ use async_chat::{FromClient, FromServer};
 use async_std::io::BufReader;
 use async_std::net::TcpStream;
 use async_std::prelude::*;
-use async_std::sync::Mutex;
-use async_std::sync::Arc;
+use async_std::sync::{Arc, Mutex};
+use anyhow::{bail, Result};
 
+/// Wraps a TCP connection to a client, allowing safe async writes.
 pub struct Outbound(Mutex<TcpStream>); 
+
 impl Outbound {
-    pub fn new(to_client: TcpStream) -> Outbound {
-        Outbound(Mutex::new(to_client))
+    pub fn new(to_client: TcpStream) -> Self {
+        Self(Mutex::new(to_client))
     }
-    pub async fn send(&self, packet: FromServer) -> anyhow::Result<()> {
+
+    pub async fn send(&self, packet: FromServer) -> Result<()> {
         let mut guard = self.0.lock().await;
         utils::send_as_json(&mut *guard, &packet).await?;
         guard.flush().await?;
@@ -20,15 +23,15 @@ impl Outbound {
     }
 }
 
-pub async fn serve(socket: TcpStream, groups: Arc<GroupTable>) -> anyhow::Result<()> {
-    // wrapping our connection in outbound so as to have exclusive access to it in the groups and avoid interference
+/// Handles a new client connection, listens for messages, and interacts with group logic.
+pub async fn serve(socket: TcpStream, groups: Arc<GroupTable>) -> Result<()> {
     let outbound = Arc::new(Outbound::new(socket.clone()));
     let buffered = BufReader::new(socket);
-    // receive data from clients
     let mut from_client = utils::receive_as_json(buffered);
+
     while let Some(request_result) = from_client.next().await {
         let request = request_result?;
-        let result = match request {
+        let result: Result<()> = match request {
             FromClient::Join { group_name } => {
                 let group = groups.get_or_create(group_name);
                 group.join(outbound.clone());
@@ -42,15 +45,16 @@ pub async fn serve(socket: TcpStream, groups: Arc<GroupTable>) -> anyhow::Result
                     group.post(message);
                     Ok(())
                 }
-                None => Err(format!("Group '{}' does not exist", group_name)),
+                None => bail!("Group '{}' does not exist", group_name),
             },
         };
-        // not a valid request
+
         if let Err(message) = result {
-            let report = FromServer::Error(message);
-            // send error back to client
+            let report = FromServer::Error(message.to_string());
             outbound.send(report).await?;
         }
     }
+
+    println!("Client disconnected.");
     Ok(())
 }

From ef7095caf144181e2e3a62978ed698407e49b1a7 Mon Sep 17 00:00:00 2001
From: nafissatou <nafisatouhamadou2@gmail.com>
Date: Sun, 6 Apr 2025 20:18:32 +0100
Subject: [PATCH 2/3] Initial commit with connection.rs fix and cleanup

---
 src/bin/server/connection.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/bin/server/connection.rs b/src/bin/server/connection.rs
index b216e3f..c5f6ce6 100644
--- a/src/bin/server/connection.rs
+++ b/src/bin/server/connection.rs
@@ -10,6 +10,7 @@ use anyhow::{bail, Result};
 /// Wraps a TCP connection to a client, allowing safe async writes.
 pub struct Outbound(Mutex<TcpStream>); 
 
+
 impl Outbound {
     pub fn new(to_client: TcpStream) -> Self {
         Self(Mutex::new(to_client))

From 445db34e6ff9b8da00c770702f9ea6f73e3189f3 Mon Sep 17 00:00:00 2001
From: nafissatou <nafisatouhamadou2@gmail.com>
Date: Sun, 6 Apr 2025 21:35:33 +0100
Subject: [PATCH 3/3] well formated code

---
 src/bin/server/connection.rs | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/src/bin/server/connection.rs b/src/bin/server/connection.rs
index 72ca7f2..3935b22 100644
--- a/src/bin/server/connection.rs
+++ b/src/bin/server/connection.rs
@@ -9,8 +9,7 @@ use async_std::sync::{Arc, Mutex};
 use anyhow::{bail, Result};
 
 /// Wraps a TCP connection to a client, allowing safe async writes.
-pub struct Outbound(Mutex<TcpStream>); 
-
+pub struct Outbound(Mutex<TcpStream>);
 
 
 use async_std::sync::Arc;
@@ -39,16 +38,14 @@ pub async fn serve(socket: TcpStream, groups: Arc<GroupTable>) -> Result<()> {
 
     while let Some(request_result) = from_client.next().await {
         let request = request_result?;
+
         let result: Result<()> = match request {
             FromClient::Join { group_name } => {
                 let group = groups.get_or_create(group_name);
                 group.join(outbound.clone());
                 Ok(())
             }
-            FromClient::Post {
-                group_name,
-                message,
-            } => match groups.get(&group_name) {
+            FromClient::Post { group_name, message } => match groups.get(&group_name) {
                 Some(group) => {
                     group.post(message);
                     Ok(())