Got session control into it's own layer.

Cargo.lock

@@ -106,7 +106,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "edca88bc138befd0323b20752846e6587272d3b03b0343c8ea28a6f819e6e71f"
 dependencies = [
  "async-trait",
- "axum-core",
+ "axum-core 0.4.5",
  "bytes",
  "futures-util",
  "http",
@@ -154,6 +154,25 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "axum-core"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68464cd0412f486726fb3373129ef5d2993f90c34bc2bc1c1e9943b2f4fc7ca6"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "http",
+ "http-body",
+ "http-body-util",
+ "mime",
+ "pin-project-lite",
+ "rustversion",
+ "sync_wrapper",
+ "tower-layer",
+ "tower-service",
+]
+
 [[package]]
 name = "axum-extra"
 version = "0.9.6"
@@ -161,7 +180,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c794b30c904f0a1c2fb7740f7df7f7972dfaa14ef6f57cb6178dc63e5dca2f04"
 dependencies = [
  "axum",
- "axum-core",
+ "axum-core 0.4.5",
  "bytes",
  "cookie",
  "fastrand",
@@ -228,9 +247,9 @@ checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
 
 [[package]]
 name = "cc"
-version = "1.2.18"
+version = "1.2.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "525046617d8376e3db1deffb079e91cef90a89fc3ca5c185bbf8c9ecdd15cd5c"
+checksum = "8e3a13707ac958681c13b39b458c073d0d9bc8a22cb1b2f4c8e55eb72c13f362"
 dependencies = [
  "shlex",
 ]
@@ -257,9 +276,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.35"
+version = "4.5.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8aa86934b44c19c50f87cc2790e19f54f7a67aedb64101c2e1a2e5ecfb73944"
+checksum = "2df961d8c8a0d08aa9945718ccf584145eee3f3aa06cddbeac12933781102e04"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -267,9 +286,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.35"
+version = "4.5.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2414dbb2dd0695280da6ea9261e327479e9d37b0630f6b53ba2a11c60c679fd9"
+checksum = "132dbda40fb6753878316a489d5a1242a8ef2f0d9e47ba01c951ea8aa7d013a5"
 dependencies = [
  "anstream",
  "anstyle",
@@ -407,6 +426,17 @@ version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
 
+[[package]]
+name = "futures-macro"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "futures-task"
 version = "0.3.31"
@@ -420,9 +450,11 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
 dependencies = [
  "futures-core",
+ "futures-macro",
  "futures-task",
  "pin-project-lite",
  "pin-utils",
+ "slab",
 ]
 
 [[package]]
@@ -608,9 +640,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.171"
+version = "0.2.172"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c19937216e9d3aa9956d9bb8dfc0b0c8beb6058fc4f7a4dc4d850edf86a237d6"
+checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
 
 [[package]]
 name = "lock_api"
@@ -677,6 +709,7 @@ dependencies = [
  "rand",
  "tokio",
  "tower",
+ "tower-cookies",
  "uuid",
 ]
 
@@ -785,9 +818,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.94"
+version = "1.0.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a31971752e70b8b2686d7e46ec17fb38dad4051d94024c88df49b667caea9c84"
+checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
 dependencies = [
  "unicode-ident",
 ]
@@ -950,6 +983,15 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "slab"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
+dependencies = [
+ "autocfg",
+]
+
 [[package]]
 name = "smallvec"
 version = "1.15.0"
@@ -1077,6 +1119,22 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "tower-cookies"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "151b5a3e3c45df17466454bb74e9ecedecc955269bdedbf4d150dfa393b55a36"
+dependencies = [
+ "axum-core 0.5.2",
+ "cookie",
+ "futures-util",
+ "http",
+ "parking_lot",
+ "pin-project-lite",
+ "tower-layer",
+ "tower-service",
+]
+
 [[package]]
 name = "tower-layer"
 version = "0.3.3"

Cargo.toml

@@ -12,6 +12,7 @@ chrono = { version = "0.4.40", features = ["now"] }
 clap = { version = "4.5.1", features = ["derive"] }
 rand = "0.8.5"
 tokio = { version = "1.36.0", features = ["full"] }
+tower-cookies = "0.11.0"
 uuid = { version = "1.8.0", features = ["v4"] }
 
 [dev-dependencies]

src/client.rs

@@ -15,368 +15,165 @@ use uuid::Uuid;
 
 const RESPONS_TO: [MsgType; 2] = [MsgType::Document, MsgType::SessionValidated];
 
-pub struct Request {
-    pub session: Option<Field>,
-}
-
-impl Request {
-    pub fn new(session: Option<Field>) -> Self {
-        Self { session: session }
-    }
-}
-
-#[cfg(test)]
-pub mod requests {
-    use super::*;
-
-    pub fn get_root_document() -> Request {
-        Request::new(None)
-    }
-
-    pub fn get_root_with_session(sess_id: &Uuid) -> Request {
-        Request::new(Some(sess_id.clone().into()))
-    }
-
-    pub fn get_root_document_eith_session<F>(id: F) -> Request
-    where
-        F: Into<Field>,
-    {
-        Request::new(Some(id.into()))
-    }
-
-    #[test]
-    fn new_request_no_session() {
-        let sess: Option<Field> = None;
-        let req = Request::new(sess);
-        assert!(req.session.is_none(), "should not have a session")
-    }
-
-    #[test]
-    fn new_request_with_session() {
-        let id = Uuid::new_v4();
-        let req = Request::new(Some(id.into()));
-        match req.session {
-            Some(result) => assert_eq!(result.to_uuid().unwrap(), id),
-            None => unreachable!("should contain a session"),
-        }
-    }
-}
-
-pub struct Reply {
-    sess_id: Uuid,
-    content: String,
-}
-
-impl Reply {
-    fn new(sess_id: Uuid, content: String) -> Self {
-        Self {
-            sess_id: sess_id,
-            content: content,
-        }
-    }
-
-    pub fn get_session(&self) -> Uuid {
-        self.sess_id.clone()
-    }
-
-    pub fn get_content(&self) -> String {
-        self.content.clone()
-    }
-}
-
-#[cfg(test)]
-mod replies {
-    use super::*;
-
-    pub fn create_reply() -> Reply {
-        Reply {
-            sess_id: Uuid::new_v4(),
-            content: "some text".to_string(),
-        }
-    }
-
-    #[test]
-    fn create_new_reply() {
-        let sess_id = Uuid::new_v4();
-        let txt = Uuid::new_v4().to_string();
-        let reply = Reply::new(sess_id, txt.clone());
-        assert_eq!(reply.get_session(), sess_id);
-        assert_eq!(reply.get_content(), txt);
-    }
-}
-
 #[derive(Clone)]
-pub struct ClientRegistry {
+pub struct ClientChannel {
-    registry: Arc<Mutex<HashMap<Uuid, Sender<Reply>>>>,
+    queue: Queue,
+    registry: Arc<Mutex<HashMap<Uuid, Sender<Message>>>>,
 }
 
-impl ClientRegistry {
+impl ClientChannel {
-    pub fn new() -> Self {
+    fn new(queue: Queue) -> Self {
         Self {
+            queue: queue,
             registry: Arc::new(Mutex::new(HashMap::new())),
         }
     }
 
-    fn get_id<'a>(
+    pub fn send(&self, mut msg: Message) -> Receiver<Message> {
-        gen: &mut impl Iterator<Item = Uuid>,
-        data: &HashMap<Uuid, Sender<Reply>>,
-    ) -> Uuid {
-        let mut id = gen.next().unwrap();
-        while data.contains_key(&id) {
-            id = gen.next().unwrap();
-        }
-        id.clone()
-    }
-
-    pub fn add(&mut self, tx: Sender<Reply>) -> Uuid {
         let mut reg = self.registry.lock().unwrap();
-        let mut gen_id = GenID::new();
+        if reg.contains_key(&msg.get_id()) {
-        let id = ClientRegistry::get_id(&mut gen_id, &reg);
+            let mut id = Uuid::new_v4();
-        reg.insert(id.clone(), tx);
+            while reg.contains_key(&id) {
-        id
+                id = Uuid::new_v4();
-    }
+            }
-
+            msg.reset_id(id);
-    fn send(&mut self, id: &Uuid, msg: Reply) {
-        let mut reg = self.registry.lock().unwrap();
-        let tx = reg.remove(id).unwrap();
-        tx.send(msg).unwrap();
-    }
-}
-
-#[cfg(test)]
-mod clientregistries {
-    use super::*;
-    use crate::client::replies::create_reply;
-    use std::{
-        sync::mpsc::{channel, Receiver},
-        time::Duration,
-    };
-
-    static TIMEOUT: Duration = Duration::from_millis(500);
-
-    #[test]
-    fn create_client_registry() {
-        let reg = ClientRegistry::new();
-        let data = reg.registry.lock().unwrap();
-        assert!(data.is_empty(), "needs to create an empty hashmap");
-    }
-
-    #[test]
-    fn send_from_client() {
-        let mut reg = ClientRegistry::new();
-        let count = 10;
-        let mut rxs: HashMap<Uuid, Receiver<Reply>> = HashMap::new();
-        for _ in 0..count {
-            let (tx, rx) = channel::<Reply>();
-            let id = reg.add(tx);
-            rxs.insert(id, rx);
         }
-        assert_eq!(rxs.len(), count, "should have been {} receivers", count);
-        for (id, rx) in rxs.iter() {
-            let msg = create_reply();
-            reg.send(id, msg);
-            rx.recv_timeout(TIMEOUT).unwrap();
-        }
-        let data = reg.registry.lock().unwrap();
-        assert!(data.is_empty(), "should remove sender after sending");
-    }
-
-    #[test]
-    fn prevent_duplicates() {
-        let mut reg = ClientRegistry::new();
-        let (tx, _rx) = channel::<Reply>();
-        let existing = reg.add(tx);
-        let expected = Uuid::new_v4();
-        let ids = [existing.clone(), expected.clone()];
-        let data = reg.registry.lock().unwrap();
-        let result = ClientRegistry::get_id(&mut ids.into_iter(), &data);
-        assert_eq!(result, expected);
-    }
-}
-
-#[derive(Clone)]
-pub struct ClientLink {
-    tx: Sender<Message>,
-    registry: ClientRegistry,
-}
-
-impl ClientLink {
-    fn new(tx: Sender<Message>, registry: ClientRegistry) -> Self {
-        Self {
-            tx: tx,
-            registry: registry,
-        }
-    }
-
-    pub fn send(&mut self, req: Request) -> Receiver<Reply> {
         let (tx, rx) = channel();
-        let mut msg: Message = req.into();
+        reg.insert(msg.get_id(), tx);
-        let id = self.registry.add(tx);
+        self.queue.send(msg);
-        msg.add_data("tx_id", id);
-        self.tx.send(msg).unwrap();
         rx
     }
+
+    fn reply(&self, msg: Message) {
+        let mut reg = self.registry.lock().unwrap();
+        match reg.remove(&msg.get_id()) {
+            Some(tx) => tx.send(msg).unwrap(),
+            None => {}
+        }
+    }
 }
 
 #[cfg(test)]
-mod clientlinks {
+mod client_channels {
     use super::*;
-    use crate::client::replies::create_reply;
     use std::time::Duration;
 
     static TIMEOUT: Duration = Duration::from_millis(500);
 
     #[test]
-    fn create_client_link() {
+    fn request_new_message() {
+        let queue = Queue::new();
+        let chan = ClientChannel::new(queue);
+        let msg_types = [MsgType::Document, MsgType::Time];
+        for msg_type in msg_types.iter() {
+            let msg = Message::new(msg_type.clone());
+            assert_eq!(msg.get_msg_type(), msg_type);
+        }
+    }
+
+    #[test]
+    fn fowards_message() {
+        let msg_type = MsgType::Document;
+        let reply_type = MsgType::Time;
+        let queue = Queue::new();
         let (tx, rx) = channel();
-        let mut registry = ClientRegistry::new();
+        queue.add(tx, [msg_type.clone()].to_vec());
-        let mut link = ClientLink::new(tx, registry.clone());
+        let chan = ClientChannel::new(queue);
-        let req = Request::new(None);
+        let msg = Message::new(msg_type.clone());
-        let rx_client = link.send(req);
+        let client_rx = chan.send(msg.clone());
-        let msg = rx.recv_timeout(TIMEOUT).unwrap();
+        let reply = rx.recv_timeout(TIMEOUT).unwrap();
-        match msg.get_msg_type() {
+        assert_eq!(reply.get_id(), msg.get_id());
-            MsgType::ClientRequest => {}
+        assert_eq!(reply.get_msg_type().clone(), msg_type);
-            _ => unreachable!("should have been a client request"),
+        let client_reply = reply.reply(MsgType::Time);
-        }
+        chan.reply(client_reply);
-        match msg.get_data("tx_id") {
+        let client_msg = client_rx.recv_timeout(TIMEOUT).unwrap();
-            Some(result) => {
+        assert_eq!(client_msg.get_id(), msg.get_id());
-                let id = result.to_uuid().unwrap();
+        assert_eq!(client_msg.get_msg_type().clone(), reply_type);
-                registry.send(&id, create_reply());
+    }
-                rx_client.recv().unwrap();
+
-            }
+    #[test]
-            None => unreachable!("should have had a seender id"),
+    fn no_duplicate_ids() {
-        }
+        let (tx, rx) = channel();
+        let queue = Queue::new();
+        queue.add(tx, [MsgType::Time].to_vec());
+        let chan = ClientChannel::new(queue);
+        let msg1 = Message::new(MsgType::Time);
+        let msg2 = msg1.reply(MsgType::Time);
+        let rx1 = chan.send(msg1);
+        let rx2 = chan.send(msg2);
+        let queue1 = rx.recv_timeout(TIMEOUT).unwrap();
+        let queue2 = rx.recv_timeout(TIMEOUT).unwrap();
+        assert_ne!(queue1.get_id(), queue2.get_id());
+        chan.reply(queue1.reply(MsgType::Document));
+        chan.reply(queue2.reply(MsgType::Document));
+        let reply1 = rx1.recv_timeout(TIMEOUT).unwrap();
+        let reply2 = rx2.recv_timeout(TIMEOUT).unwrap();
+        assert_eq!(reply1.get_id(), queue1.get_id());
+        assert_eq!(reply2.get_id(), queue2.get_id());
+    }
+
+    #[test]
+    fn ignore_unrequested() {
+        let queue = Queue::new();
+        let chan = ClientChannel::new(queue);
+        chan.reply(Message::new(MsgType::Document));
     }
 }
 
 pub struct Client {
+    channel: ClientChannel,
     queue: Queue,
-    registry: ClientRegistry,
-    return_to: HashMap<Uuid, Message>,
     rx: Receiver<Message>,
 }
 
 impl Client {
-    fn new(rx: Receiver<Message>, queue: Queue) -> Self {
+    fn new(chan: ClientChannel, queue: Queue, rx: Receiver<Message>) -> Self {
         Self {
+            channel: chan,
             queue: queue,
-            registry: ClientRegistry::new(),
-            return_to: HashMap::new(),
             rx: rx,
         }
     }
 
-    pub fn start(queue: Queue) -> ClientLink {
+    pub fn start(queue: Queue) -> ClientChannel {
         let (tx, rx) = channel();
         queue.add(tx.clone(), RESPONS_TO.to_vec());
-        let mut client = Client::new(rx, queue);
+        let chan = ClientChannel::new(queue.clone());
-        let link = ClientLink::new(tx, client.get_registry());
+        let client = Client::new(chan.clone(), queue, rx);
         spawn(move || {
             client.listen();
         });
-        link
+        chan
     }
 
-    fn listen(&mut self) {
+    fn listen(&self) {
         loop {
             let msg = self.rx.recv().unwrap();
-            match msg.get_msg_type() {
+            self.channel.reply(msg);
-                MsgType::ClientRequest => self.client_request(msg),
-                MsgType::Document => self.document(msg),
-                MsgType::SessionValidated => self.session(msg),
-                _ => unreachable!("Received message it did not understand"),
-            }
         }
     }
-
-    fn get_registry(&self) -> ClientRegistry {
-        self.registry.clone()
-    }
-
-    fn client_request(&mut self, msg: Message) {
-        self.return_to.insert(msg.get_id(), msg.clone());
-        let mut reply = msg.reply(MsgType::SessionValidate);
-        match msg.get_data("sess_id") {
-            Some(sess_id) => reply.add_data("sess_id", sess_id.clone()),
-            None => {}
-        }
-        self.queue.send(reply).unwrap();
-    }
-
-    fn session(&mut self, msg: Message) {
-        let initial_msg = self.return_to.get_mut(&msg.get_id()).unwrap();
-        let mut reply = msg.reply(MsgType::DocumentRequest);
-        match msg.get_data("sess_id") {
-            Some(sess_id) => {
-                initial_msg.add_data("sess_id", sess_id.clone());
-                reply.add_data("sess_id", sess_id.clone());
-            }
-            None => unreachable!("validated should always have an id"),
-        }
-        self.queue.send(reply).unwrap();
-    }
-
-    fn document(&mut self, msg: Message) {
-        let initial_msg = self.return_to.remove(&msg.get_id()).unwrap();
-        let tx_id = initial_msg.get_data("tx_id").unwrap().to_uuid().unwrap();
-        let reply = Reply::new(
-            initial_msg.get_data("sess_id").unwrap().to_uuid().unwrap(),
-            msg.get_data("doc").unwrap().to_string(),
-        );
-        self.registry.send(&tx_id, reply);
-    }
 }
 
 #[cfg(test)]
 mod clients {
     use super::*;
-    use requests::get_root_with_session;
+    use crate::session::sessions::create_validated_reply;
     use std::time::Duration;
 
     static TIMEOUT: Duration = Duration::from_millis(500);
 
     #[test]
-    fn start_client() {
+    fn session_validated() {
-        let sess_id1 = Uuid::new_v4();
-        let sess_id2 = Uuid::new_v4();
-        let doc = Uuid::new_v4().to_string();
-        let (tx, rx) = channel();
         let queue = Queue::new();
-        queue.add(
+        let (queue_tx, queue_rx) = channel();
-            tx,
+        queue.add(queue_tx, [MsgType::SessionValidate].to_vec());
-            [MsgType::SessionValidate, MsgType::DocumentRequest].to_vec(),
+        let chan = Client::start(queue.clone());
-        );
+        let chan_rx = chan.send(Message::new(MsgType::SessionValidate));
-        let mut link = Client::start(queue.clone());
+        let msg = queue_rx.recv_timeout(TIMEOUT).unwrap();
-        let req = get_root_with_session(&sess_id1);
+        let expected = create_validated_reply(msg);
-        let reply_rx = link.send(req);
+        queue.send(expected.clone());
-        let send1 = rx.recv_timeout(TIMEOUT).unwrap();
+        let result = chan_rx.recv_timeout(TIMEOUT).unwrap();
-        match send1.get_msg_type() {
+        assert_eq!(result.get_id(), expected.get_id());
-            MsgType::SessionValidate => {}
+        assert_eq!(result.get_msg_type(), expected.get_msg_type());
-            _ => unreachable!("should request session validation"),
-        }
-        assert_eq!(
-            send1.get_data("sess_id").unwrap().to_uuid().unwrap(),
-            sess_id1
-        );
-        assert!(send1.get_data("tx_id").is_none());
-        let mut response = send1.reply_with_data(MsgType::SessionValidated);
-        response.add_data("sess_id", sess_id2);
-        queue.send(response).unwrap();
-        let send2 = rx.recv_timeout(TIMEOUT).unwrap();
-        assert_eq!(send2.get_id(), send1.get_id());
-        match send2.get_msg_type() {
-            MsgType::DocumentRequest => {}
-            _ => unreachable!("should request session validation"),
-        }
-        assert_eq!(
-            send2.get_data("sess_id").unwrap().to_uuid().unwrap(),
-            sess_id2
-        );
-        let mut document = send2.reply(MsgType::Document);
-        document.add_data("doc", doc.clone());
-        queue.send(document).unwrap();
-        let reply = reply_rx.recv_timeout(TIMEOUT).unwrap();
-        assert_eq!(reply.get_session(), sess_id2);
-        assert_eq!(reply.get_content(), doc);
     }
 }

src/document.rs

@@ -43,13 +43,17 @@ impl Document {
 }
 
 #[cfg(test)]
-mod documents {
+pub mod documents {
     use super::*;
     use std::time::Duration;
     use uuid::Uuid;
 
     const TIMEOUT: Duration = Duration::from_millis(500);
 
+    pub fn get_root_document() -> Message {
+        Message::new(MsgType::DocumentRequest)
+    }
+
     fn setup_document(listen_for: Vec<MsgType>) -> (Queue, Receiver<Message>) {
         let queue = Queue::new();
         let (tx, rx) = channel();

src/lib.rs

@@ -6,16 +6,17 @@ mod queue;
 mod session;
 mod utils;
 
-use client::{Client, ClientLink, Reply, Request};
+use client::{Client, ClientChannel};
 use clock::Clock;
 use document::Document;
 use field::Field;
-use queue::Queue;
+use queue::{Message, MsgType, Queue};
 use session::Session;
+use uuid::Uuid;
 
 #[derive(Clone)]
 pub struct MoreThanText {
-    client_link: ClientLink,
+    client_channel: ClientChannel,
 }
 
 impl MoreThanText {
@@ -25,11 +26,25 @@ impl MoreThanText {
         Document::start(queue.clone());
         Session::start(queue.clone());
         Self {
-            client_link: Client::start(queue.clone()),
+            client_channel: Client::start(queue.clone()),
         }
     }
 
-    pub fn request<F>(&mut self, session: Option<F>) -> Reply
+    pub fn validate_session<F>(&mut self, session: Option<F>) -> Uuid
+    where
+        F: Into<Field>,
+    {
+        let mut msg = Message::new(MsgType::SessionValidate);
+        match session {
+            Some(id) => msg.add_data("sess_id", id.into()),
+            None => {}
+        }
+        let rx = self.client_channel.send(msg);
+        let reply = rx.recv().unwrap();
+        reply.get_data("sess_id").unwrap().to_uuid().unwrap()
+    }
+
+    pub fn request<F>(&mut self, session: Option<F>) -> Message
     where
         F: Into<Field>,
     {
@@ -37,8 +52,8 @@ impl MoreThanText {
             Some(id) => Some(id.into()),
             None => None,
         };
-        let req = Request::new(sess);
+        let req = Message::new(MsgType::DocumentRequest);
-        let rx = self.client_link.send(req);
+        let rx = self.client_channel.send(req.into());
         rx.recv().unwrap()
     }
 }

src/main.rs

@@ -1,8 +1,17 @@
-use axum::{extract::State, response::IntoResponse, routing::get, Router};
+use axum::{
-use axum_extra::extract::cookie::{Cookie, CookieJar};
+    async_trait,
+    extract::{Extension, FromRequestParts, State},
+    http::request::Parts,
+    response::IntoResponse,
+    routing::get,
+    RequestPartsExt, Router,
+};
 use clap::Parser;
 use morethantext::MoreThanText;
+use std::convert::Infallible;
 use tokio::{spawn, sync::mpsc::channel};
+use tower_cookies::{Cookie, CookieManagerLayer, Cookies};
+use uuid::Uuid;
 
 const LOCALHOST: &str = "127.0.0.1";
 const SESSION_KEY: &str = "sessionid";
@@ -34,23 +43,48 @@ async fn main() {
 }
 
 async fn create_app(state: MoreThanText) -> Router {
-    Router::new().route("/", get(mtt_conn)).with_state(state)
+    Router::new()
+        .route("/", get(mtt_conn))
+        .layer(CookieManagerLayer::new())
+        .layer(Extension(state.clone()))
+        .with_state(state)
 }
 
-async fn mtt_conn(jar: CookieJar, state: State<MoreThanText>) -> impl IntoResponse {
+#[derive(Clone)]
-    let sid = match jar.get(SESSION_KEY) {
+struct SessionID(Uuid);
-        Some(cookie) => Some(cookie.value().to_string()),
+
-        None => None,
+#[async_trait]
-    };
+impl<S> FromRequestParts<S> for SessionID
-    let sess_info = sid.clone();
+where
-    let (tx, mut rx) = channel(5);
+    S: Send + Sync,
-    spawn(async move {
+{
-        tx.send(state.clone().request(sess_info)).await.unwrap();
+    type Rejection = Infallible;
-    });
+
-    let reply = rx.recv().await.unwrap();
+    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
-    let cookie = Cookie::build((SESSION_KEY, reply.get_session().to_string()));
+        let Extension(cookies) = parts.extract::<Extension<Cookies>>().await.unwrap();
-    let cookies = jar.add(cookie);
+        let Extension(mut state) = parts.extract::<Extension<MoreThanText>>().await.unwrap();
-    (cookies, reply.get_content())
+        let req_id = match cookies.get(SESSION_KEY) {
+            Some(cookie) => Some(cookie.value().to_string()),
+            None => None,
+        };
+        let requested = req_id.clone();
+        let (tx, mut rx) = channel(1);
+        spawn(async move {
+            tx.send(state.validate_session(requested)).await.unwrap();
+        });
+        let id = rx.recv().await.unwrap();
+        if !req_id.is_some_and(|x| x == id.to_string()) {
+            cookies.add(Cookie::new(SESSION_KEY, id.to_string()));
+        }
+        Ok(SessionID(id))
+    }
+}
+
+async fn mtt_conn(
+    sess_id: SessionID,
+    state: State<MoreThanText>,
+) -> impl IntoResponse {
+    ("something".to_string(),)
 }
 
 #[cfg(test)]
@@ -58,7 +92,10 @@ mod servers {
     use super::*;
     use axum::{
         body::Body,
-        http::{Request, StatusCode},
+        http::{
+            header::{COOKIE, SET_COOKIE},
+            Request, StatusCode,
+        },
     };
     use tower::ServiceExt;
 
@@ -70,7 +107,7 @@ mod servers {
             .await
             .unwrap();
         assert_eq!(response.status(), StatusCode::OK);
-        let sessid = format!("{:?}", response.headers().get("set-cookie").unwrap());
+        let sessid = format!("{:?}", response.headers().get(SET_COOKIE).unwrap());
         assert!(sessid.contains(SESSION_KEY), "did not set session id");
     }
 
@@ -84,7 +121,7 @@ mod servers {
                 .oneshot(Request::builder().uri("/").body(Body::empty()).unwrap())
                 .await
                 .unwrap();
-            let sessid = format!("{:?}", response.headers().get("set-cookie").unwrap());
+            let sessid = format!("{:?}", response.headers().get(SET_COOKIE).unwrap());
             assert!(
                 !holder.contains(&sessid),
                 "found duplicate entry: {:?}",
@@ -94,6 +131,29 @@ mod servers {
         }
     }
 
+    #[tokio::test]
+    async fn cookie_only_issued_once() {
+        let app = create_app(MoreThanText::new()).await;
+        let initial = app
+            .clone()
+            .oneshot(Request::builder().uri("/").body(Body::empty()).unwrap())
+            .await
+            .unwrap();
+        assert_eq!(initial.status(), StatusCode::OK);
+        let sessid = initial.headers().get(SET_COOKIE).unwrap();
+        let mut request = Request::builder()
+            .uri("/")
+            .header(COOKIE, sessid.clone())
+            .body(Body::empty())
+            .unwrap();
+        let response = app.clone().oneshot(request).await.unwrap();
+        assert_eq!(response.status(), StatusCode::OK);
+        match response.headers().get(SET_COOKIE) {
+            Some(info) => assert!(false, "first pass: {:?}, second pass: {:?}", sessid, info),
+            None => {}
+        }
+    }
+
     #[tokio::test]
     async fn receive_file_not_found() {
         let app = create_app(MoreThanText::new()).await;

src/queue.rs

@@ -1,4 +1,4 @@
-use crate::{client::Request, field::Field};
+use crate::field::Field;
 use std::{
     collections::HashMap,
     sync::{mpsc::Sender, Arc, RwLock},
@@ -70,23 +70,16 @@ impl Message {
     pub fn get_id(&self) -> Uuid {
         self.id.clone()
     }
-}
 
-impl From<Request> for Message {
+    pub fn reset_id(&mut self, id: Uuid) {
-    fn from(value: Request) -> Self {
+        self.id = id;
-        let mut msg = Message::new(MsgType::ClientRequest);
-        match value.session {
-            Some(id) => msg.add_data("sess_id", id),
-            None => {}
-        }
-        msg
     }
 }
 
 #[cfg(test)]
 mod messages {
     use super::*;
-    use crate::client::requests::{get_root_document, get_root_document_eith_session};
+    use crate::document::documents::get_root_document;
 
     #[test]
     fn new_message() {
@@ -182,24 +175,10 @@ mod messages {
     }
 
     #[test]
-    fn from_request_no_session() {
+    fn reset_msg_id() {
-        let req = get_root_document();
+        let mut msg = Message::new(MsgType::Time);
-        let msg: Message = req.into();
+        msg.reset_id(Uuid::nil());
-        assert!(
+        assert_eq!(msg.get_id(), Uuid::nil());
-            msg.get_data("sess_id").is_none(),
-            "should not have a session id"
-        )
-    }
-
-    #[test]
-    fn from_request_with_session() {
-        let id = Uuid::new_v4();
-        let req = get_root_document_eith_session(id.clone());
-        let msg: Message = req.into();
-        match msg.get_data("sess_id") {
-            Some(result) => assert_eq!(result.to_uuid().unwrap(), id),
-            None => unreachable!("should return an id"),
-        }
     }
 }
 

src/session.rs

@@ -156,13 +156,19 @@ impl Session {
 }
 
 #[cfg(test)]
-mod sessions {
+pub mod sessions {
     use super::*;
     use crate::queue::{Message, MsgType};
     use std::{sync::mpsc::channel, time::Duration};
 
     static TIMEOUT: Duration = Duration::from_millis(500);
 
+    pub fn create_validated_reply(msg: Message) -> Message {
+        let mut reply = msg.reply(MsgType::SessionValidated);
+        reply.add_data("sess_id", Uuid::new_v4());
+        reply
+    }
+
     fn setup_session(listen_for: Vec<MsgType>) -> (Queue, Receiver<Message>) {
         let queue = Queue::new();
         let (tx, rx) = channel();