From e16c0ed4aea0ecd806f1168ecbe8878014749d86 Mon Sep 17 00:00:00 2001
From: Jeff Baskin <jeff.l.baskin@gmail.com>
Date: Wed, 9 Apr 2025 00:48:37 -0400
Subject: [PATCH] Added session storage.

---
 src/session.rs | 76 +++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 66 insertions(+), 10 deletions(-)

diff --git a/src/session.rs b/src/session.rs
index 3a8b496..b429a5f 100644
--- a/src/session.rs
+++ b/src/session.rs
@@ -1,5 +1,9 @@
-use crate::queue::{Message, MsgType, Queue};
+use crate::{
+    field::Field,
+    queue::{Message, MsgType, Queue},
+};
 use std::{
+    collections::HashMap,
     sync::mpsc::{channel, Receiver},
     thread::spawn,
 };
@@ -7,7 +11,10 @@ use uuid::Uuid;
 
 const RESPONDS_TO: [MsgType; 1] = [MsgType::SessionValidate];
 
+struct SessionData;
+
 pub struct Session {
+    data: HashMap<Uuid, SessionData>,
     queue: Queue,
     rx: Receiver<Message>,
 }
@@ -15,6 +22,7 @@ pub struct Session {
 impl Session {
     fn new(queue: Queue, rx: Receiver<Message>) -> Self {
         Self {
+            data: HashMap::new(),
             queue: queue,
             rx: rx,
         }
@@ -22,26 +30,48 @@ impl Session {
 
     pub fn start(queue: Queue) {
         let (tx, rx) = channel();
-        let session = Session::new(queue, rx);
+        let mut session = Session::new(queue, rx);
         session.queue.add(tx, RESPONDS_TO.to_vec());
         spawn(move || {
             session.listen();
         });
     }
 
-    fn listen(&self) {
+    fn listen(&mut self) {
         loop {
             let msg = self.rx.recv().unwrap();
             self.validate(msg);
         }
     }
 
-    fn validate(&self, msg: Message) {
-        let mut reply = msg.reply(MsgType::Session);
+    fn validate(&mut self, msg: Message) {
         match msg.get_data("sess_id") {
-            Some(id) => reply.add_data("sess_id", id.clone()),
-            None => reply.add_data("sess_id", Uuid::new_v4()),
+            Some(sid) => {
+                match sid { 
+                    Field::Uuid(sess_id) => {
+                        if self.data.contains_key(&sess_id) {
+                            let mut reply = msg.reply(MsgType::Session);
+                            reply.add_data("sess_id", sess_id.clone());
+                             self.queue.send(reply);
+                        } else {
+                            self.new_session(msg);
+                        }
+                    },
+                    _ => self.new_session(msg),
+                }
+            },
+            None => self.new_session(msg),
         }
+    }
+
+    fn new_session(&mut self, msg: Message) {
+        let mut id = Uuid::new_v4();
+        while self.data.contains_key(&id) {
+            id = Uuid::new_v4();
+        }
+        self.data.insert(id.clone(), SessionData {});
+        let mut reply = msg.reply(MsgType::Session);
+        reply.add_data("sess_id", id);
         self.queue.send(reply);
     }
 }
@@ -87,7 +117,7 @@ mod sessions {
         let mut ids: Vec<Uuid> = Vec::new();
         for _ in 0..10 {
             queue.send(msg.clone());
-            let result = rx.recv().unwrap();
+            let result = rx.recv_timeout(TIMEOUT).unwrap();
             let id = result.get_data("sess_id").unwrap().to_uuid().unwrap();
             assert!(!ids.contains(&id), "{} is a duplicate id", id);
             ids.push(id);
@@ -100,12 +130,38 @@ mod sessions {
         let (queue, rx) = setup_session(listen_for.to_vec());
         let mut msg = Message::new(MsgType::SessionValidate);
         queue.send(msg.clone());
-        let holder = rx.recv().unwrap();
+        let holder = rx.recv_timeout(TIMEOUT).unwrap();
         let id = holder.get_data("sess_id").unwrap().to_uuid().unwrap();
         msg.add_data("sess_id", id.clone());
         queue.send(msg);
-        let result = rx.recv().unwrap();
+        let result = rx.recv_timeout(TIMEOUT).unwrap();
         let output = result.get_data("sess_id").unwrap().to_uuid().unwrap();
         assert_eq!(output, id);
     }
+
+    #[test]
+    fn issue_new_if_validated_doe_not_exist() {
+        let id = Uuid::new_v4();
+        let listen_for = [MsgType::Session];
+        let (queue, rx) = setup_session(listen_for.to_vec());
+        let mut msg = Message::new(MsgType::SessionValidate);
+        msg.add_data("sess_id", id.clone());
+        queue.send(msg);
+        let result = rx.recv_timeout(TIMEOUT).unwrap();
+        let output = result.get_data("sess_id").unwrap().to_uuid().unwrap();
+        assert_ne!(output, id);
+    }
+
+    #[test]
+    fn new_for_bad_uuid() {
+        let id = "bad uuid";
+        let listen_for = [MsgType::Session];
+        let (queue, rx) = setup_session(listen_for.to_vec());
+        let mut msg = Message::new(MsgType::SessionValidate);
+        msg.add_data("sess_id", id);
+        queue.send(msg);
+        let result = rx.recv_timeout(TIMEOUT).unwrap();
+        let output = result.get_data("sess_id").unwrap().to_string();
+        assert_ne!(output, id);
+    }
 }