From 5dd0fafce20ed37fdc97dc96539391ebdebffaff Mon Sep 17 00:00:00 2001
From: metamuffin <metamuffin@disroot.org>
Date: Sat, 6 Jul 2024 01:19:02 +0200
Subject: generalize to support requests. untested

---
 src/transport/tcp.rs | 47 +++++++++++++++++++----------------------------
 1 file changed, 19 insertions(+), 28 deletions(-)

(limited to 'src/transport/tcp.rs')

diff --git a/src/transport/tcp.rs b/src/transport/tcp.rs
index 8c0a024..efe433d 100644
--- a/src/transport/tcp.rs
+++ b/src/transport/tcp.rs
@@ -1,53 +1,44 @@
 use super::Transport;
-use crate::encoding::{request::Request, response::Response};
-use anyhow::{anyhow, Result};
+use crate::encoding::Message;
+use anyhow::Result;
 use log::debug;
 use std::str::FromStr;
 use tokio::{
     io::{AsyncBufReadExt, AsyncWriteExt, BufReader, BufWriter},
-    net::{tcp::OwnedWriteHalf, TcpStream},
-    sync::{
-        mpsc::{channel, Receiver},
-        Mutex,
+    net::{
+        tcp::{OwnedReadHalf, OwnedWriteHalf},
+        TcpStream,
     },
+    sync::Mutex,
 };
 
 pub struct TcpTransport {
     write: Mutex<BufWriter<OwnedWriteHalf>>,
-    read: Mutex<Receiver<Response>>,
+    read: Mutex<BufReader<OwnedReadHalf>>,
 }
 
 impl TcpTransport {
     pub async fn new(stream: TcpStream) -> Result<Self> {
         let (read, write) = stream.into_split();
-
-        let (tx, rx) = channel(16);
-
-        tokio::task::spawn(async move {
-            let mut sock = BufReader::new(read);
-            let mut message = String::new();
-            loop {
-                while !message.ends_with("\r\n\r\n") {
-                    sock.read_line(&mut message).await.unwrap();
-                }
-                let mesg = Response::from_str(message.trim()).unwrap();
-                debug!("<- {mesg}");
-                tx.send(mesg).await.unwrap();
-                message.clear();
-            }
-        });
-
         Ok(Self {
             write: BufWriter::new(write).into(),
-            read: rx.into(),
+            read: BufReader::new(read).into(),
         })
     }
 }
+
 impl Transport for TcpTransport {
-    async fn recv(&self) -> Result<Response> {
-        self.read.lock().await.recv().await.ok_or(anyhow!("end"))
+    async fn recv(&self) -> Result<Message> {
+        let mut g = self.read.lock().await;
+        let mut message = String::new();
+        while !message.ends_with("\r\n\r\n") {
+            g.read_line(&mut message).await?;
+        }
+        let mesg = Message::from_str(message.trim())?;
+        debug!("<- {mesg}");
+        Ok(mesg)
     }
-    async fn send(&self, request: Request) -> Result<()> {
+    async fn send(&self, request: Message) -> Result<()> {
         debug!("-> {request}");
         let mut g = self.write.lock().await;
         g.write_all(format!("{request}").as_bytes()).await?;
-- 
cgit v1.2.3-70-g09d2