From 7004ce4b814b303f9868cac228cc2c7afe5efa68 Mon Sep 17 00:00:00 2001 From: Jeff Baskin Date: Sun, 3 May 2026 10:12:36 -0400 Subject: [PATCH] Replaced session id with SessionEntry. --- src/message.rs | 49 ++++++++++--------------- src/queue/data_director.rs | 73 ++++++++++++++++++++++++++++++-------- 2 files changed, 77 insertions(+), 45 deletions(-) diff --git a/src/message.rs b/src/message.rs index 3cfd3fc..efbbfec 100644 --- a/src/message.rs +++ b/src/message.rs @@ -1,7 +1,7 @@ use crate::{ action::{Field, MsgAction}, name::NameType, - queue::data_director::{Include, Path, Route}, + queue::data_director::{Include, Path, Route, SessionEntry}, }; use uuid::Uuid; @@ -41,7 +41,7 @@ pub struct Message { msg_id: MessageID, action: MsgAction, route: Route, - session: Field, + session: SessionEntry, } impl Message { @@ -58,10 +58,15 @@ impl Message { output } + pub fn session_id(&self) -> &Field { + self.session.id() + } + pub fn set_session(&self, session: F) -> Self where F: Into, { + /* let sess_id = match session.into() { Field::Uuid(data) => Field::Uuid(data.clone()), Field::StaticString(data) => match Uuid::try_from(data) { @@ -70,8 +75,10 @@ impl Message { }, _ => Field::None, }; + */ let mut output = self.clone(); - output.session = sess_id; + // output.session = sess_id; + output.session = SessionEntry::new(session); output } @@ -115,7 +122,7 @@ impl Default for Message { msg_id: MessageID::new(), action: MsgAction::None, route: Route::default(), - session: Field::None, + session: SessionEntry::new(Field::None), } } } @@ -141,7 +148,7 @@ mod messages { MsgAction::None => {} _ => panic!("should have been no action"), } - assert_eq!(msg.session, Field::None); + assert_eq!(msg.session_id(), &Field::None); } #[test] @@ -150,11 +157,11 @@ mod messages { let qry = Query::new(doc_name.clone()); let msg = Message::new(qry); let expected: NameType = doc_name.into(); - match msg.action { + match &msg.action { MsgAction::Query(data) => assert_eq!(data.doc_name(), &expected), _ => unreachable!("should have been a query"), } - match msg.session { + match msg.session_id() { Field::None => {} _ => unreachable!("should have been none"), } @@ -175,25 +182,16 @@ mod messages { let qry = Query::new(doc_name.clone()); let sess_id: Field = Uuid::new_v4().into(); let msg = Message::new(qry).set_session(sess_id.clone()); - assert_eq!(msg.session, sess_id); + assert_eq!(msg.session_id(), &sess_id); } #[test] fn can_session_be_set_by_string() { let doc_name = Name::english("string"); let qry = Query::new(doc_name.clone()); - let sess_id = Uuid::new_v4(); - let msg = Message::new(qry).set_session(sess_id.to_string()); - assert_eq!(msg.session, sess_id.into()); - } - - #[test] - fn does_garbage_return_none() { - let doc_name = Name::english("garbage"); - let qry = Query::new(doc_name.clone()); - let sess_id = "not a uuid"; - let msg = Message::new(qry).set_session(sess_id); - assert_eq!(msg.session, Field::None); + let sess_id: Field = Uuid::new_v4().to_string().into(); + let msg = Message::new(qry).set_session(sess_id.clone()); + assert_eq!(msg.session_id(), &sess_id); } #[test] @@ -202,16 +200,7 @@ mod messages { let qry = Query::new(doc_name.clone()); let sess_id = Uuid::new_v4(); let msg = Message::new(qry).set_session(sess_id.clone()); - assert_eq!(msg.session, sess_id.into()); - } - - #[test] - fn does_wrong_field_type_return_none() { - let doc_name = Name::english("uuid"); - let qry = Query::new(doc_name.clone()); - let sess_id = FieldType::DateTime.get_default(); - let msg = Message::new(qry).set_session(sess_id.clone()); - assert_eq!(msg.session, Field::None); + assert_eq!(msg.session_id(), &sess_id.into()); } #[test] diff --git a/src/queue/data_director.rs b/src/queue/data_director.rs index c7d1fd9..54e4fd0 100644 --- a/src/queue/data_director.rs +++ b/src/queue/data_director.rs @@ -1,5 +1,4 @@ use super::SenderID; -use chrono::{DateTime, Utc}; use crate::{ action::{Action, Field, MsgAction}, message::{Message, MessageAction, MessageID}, @@ -7,6 +6,7 @@ use crate::{ name::{Name, NameID, NameType, Names}, queue::router::Queue, }; +use chrono::{DateTime, Utc}; use std::{ collections::{HashMap, HashSet}, sync::mpsc::Receiver, @@ -487,7 +487,7 @@ mod route_storeage { } #[derive(Clone, Debug)] -struct SessionEntry { +pub struct SessionEntry { id: Field, expire_time: DateTime, } @@ -495,14 +495,17 @@ struct SessionEntry { impl SessionEntry { const EXPIRE_IN: Duration = Duration::from_hours(1); - fn new(id: Field) -> Self { + pub fn new(id: F) -> Self + where + F: Into, + { Self { - id: id, + id: id.into(), expire_time: Utc::now() + SessionEntry::EXPIRE_IN, } } - fn id(&self) -> &Field { + pub fn id(&self) -> &Field { &self.id } @@ -528,13 +531,23 @@ mod session_entries { let entry = SessionEntry::new(id.clone()); let end = Utc::now() + SessionEntry::EXPIRE_IN; assert_eq!(entry.id(), &id); - assert!(start < entry.expire_time, "{:?} should have been after {:?}", entry.expire_time, start); - assert!(end > entry.expire_time, "{:?} should have been after {:?}", entry.expire_time, end); + assert!( + start < entry.expire_time, + "{:?} should have been after {:?}", + entry.expire_time, + start + ); + assert!( + end > entry.expire_time, + "{:?} should have been after {:?}", + entry.expire_time, + end + ); } #[test] fn can_determine_if_entry_expired() { - let mut entry = SessionEntry::new(Uuid::nil().into()); + let mut entry = SessionEntry::new(Uuid::nil()); let data = Utc::now(); entry.expire_time = data + Duration::from_secs(1); assert!(!entry.is_expired(), "entry should not be expired"); @@ -544,13 +557,23 @@ mod session_entries { #[test] fn can_expiration_be_reset() { - let mut entry = SessionEntry::new(Uuid::nil().into()); + let mut entry = SessionEntry::new(Uuid::nil()); entry.expire_time = Utc::now(); let start = Utc::now() + SessionEntry::EXPIRE_IN; entry.extend(); let end = Utc::now() + SessionEntry::EXPIRE_IN; - assert!(start < entry.expire_time, "{:?} should have been after {:?}", entry.expire_time, start); - assert!(end > entry.expire_time, "{:?} should have been after {:?}", entry.expire_time, end); + assert!( + start < entry.expire_time, + "{:?} should have been after {:?}", + entry.expire_time, + start + ); + assert!( + end > entry.expire_time, + "{:?} should have been after {:?}", + entry.expire_time, + end + ); } } @@ -633,8 +656,18 @@ mod sessions { let end = Utc::now() + SessionEntry::EXPIRE_IN; assert_eq!(result.id(), data.id()); let entry = sess.entries.get(data.id()).unwrap(); - assert!(start < entry.expire_time, "{:?} should have been after {:?}", entry.expire_time, start); - assert!(end > entry.expire_time, "{:?} should have been after {:?}", entry.expire_time, end); + assert!( + start < entry.expire_time, + "{:?} should have been after {:?}", + entry.expire_time, + start + ); + assert!( + end > entry.expire_time, + "{:?} should have been after {:?}", + entry.expire_time, + end + ); } #[test] @@ -697,8 +730,18 @@ mod sessions { sess.entries.get_mut(&lose.id).unwrap().expire_time = Utc::now() - SessionEntry::EXPIRE_IN; let keep = sess.get(&Field::None); sess.expire(); - assert_eq!(sess.entries.len(), 1, "should only contain one entry, had {:?}", sess.entries); - assert!(sess.entries.contains_key(&keep.id), "had {:?}, expected {:?}", sess.entries.keys(), &keep.id) + assert_eq!( + sess.entries.len(), + 1, + "should only contain one entry, had {:?}", + sess.entries + ); + assert!( + sess.entries.contains_key(&keep.id), + "had {:?}, expected {:?}", + sess.entries.keys(), + &keep.id + ) } }