feat: a lot of things(i lost track)

src/util.rs

@@ -1,14 +1,14 @@
-use std::cell::UnsafeCell;
-use std::marker::PhantomData;
 use std::ops::Deref;
-use log::error;
-use tokio::io::{AsyncRead, AsyncWrite};
+use std::sync::Arc;
+use log::{error, info};
+use tokio::io::{AsyncRead, AsyncWrite, AsyncWriteExt};
 use tokio::sync::mpsc::{channel, Receiver, Sender};
+use tokio::sync::Notify;
 use tokio::task;
 use rust_nex::reggie::{UnitPacketRead, UnitPacketWrite};
 
 #[derive(Clone)]
-pub struct SendingBufferConnection(Sender<Vec<u8>>);
+pub struct SendingBufferConnection(Sender<Vec<u8>>, Arc<Notify>);
 
 pub struct SplittableBufferConnection(SendingBufferConnection, Receiver<Vec<u8>>);
 
@@ -39,41 +39,53 @@ impl SplittableBufferConnection {
         let (outside_send, inside_recv) = channel::<Vec<u8>>(10);
         let (inside_send, outside_recv) = channel::<Vec<u8>>(10);
 
-        task::spawn(async move {
-            let sender = inside_send;
-            let mut recver = inside_recv;
-            let mut stream = stream;
-            loop {
-                tokio::select! {
-                    data = recver.recv() => {
-                        let Some(data) = data else {
-                            break;
-                        };
+        let notify = Arc::new(Notify::new());
 
-                        if let Err(e) = stream.send_buffer(&data[..]).await{
-                            error!("error sending data to backend: {}", e);
-                            break;
-                        }
-                    },
-                    data = stream.read_buffer() => {
-                        let data = match data{
-                            Ok(d) => d,
-                            Err(e) => {
-                                error!("error reveiving data from backend: {}", e);
+        {
+            let notify = notify.clone();
+            task::spawn(async move {
+                let sender = inside_send;
+                let mut recver = inside_recv;
+                let mut stream = stream;
+
+
+                loop {
+                    tokio::select! {
+                        data = recver.recv() => {
+                            let Some(data) = data else {
+                                break;
+                            };
+
+                            if let Err(e) = stream.send_buffer(&data[..]).await{
+                                error!("error sending data to backend: {}", e);
                                 break;
                             }
-                        };
+                        },
+                        data = stream.read_buffer() => {
+                            let data = match data{
+                                Ok(d) => d,
+                                Err(e) => {
+                                    error!("error reveiving data from backend: {}", e);
+                                    break;
+                                }
+                            };
 
-                        if let Err(e) = sender.send(data).await{
-                            error!("a send error occurred {}", e);
-                            return;
+                            if let Err(e) = sender.send(data).await{
+                                error!("a send error occurred {}", e);
+                                return;
+                            }
+                        },
+                        _ = notify.notified() => {
+                            info!("shutting down connection");
+                            break;
                         }
-                    },
+                    }
                 }
-            }
-        });
+                stream.shutdown().await;
+            });
+        }
 
-        Self(SendingBufferConnection(outside_send), outside_recv)
+        Self(SendingBufferConnection(outside_send, notify), outside_recv)
     }
 }
 
@@ -81,6 +93,15 @@ impl SendingBufferConnection{
     pub async fn send(&self, buffer: Vec<u8>) -> Option<()>{
         self.0.send(buffer).await.ok()
     }
+    pub fn is_alive(&self) -> bool{
+        !self.0.is_closed()
+    }
+    pub async fn disconnect(&self) {
+        while !self.0.is_closed() {
+            self.1.notify_waiters();
+            tokio::task::yield_now().await;
+        }
+    }
 }
 
 impl SplittableBufferConnection{