From b2bd142b22c46c82126538b837a4bbe01c396e35 Mon Sep 17 00:00:00 2001 From: Jeff Baskin Date: Mon, 26 Jan 2026 14:31:37 -0500 Subject: [PATCH] Removed logging code for now. --- src/message.rs | 244 +------------------------------------------------ 1 file changed, 1 insertion(+), 243 deletions(-) diff --git a/src/message.rs b/src/message.rs index b6f770d..bc861a5 100644 --- a/src/message.rs +++ b/src/message.rs @@ -1,18 +1,15 @@ use crate::{ - data_director::{Include, Path, RegMsg, Register, Route}, + data_director::{Include, Path, Register, Route}, document::{ definition::DocDef, field::{Field, FieldType}, }, mtterror::MTTError, name::{NameType, Names}, - router::Queue, }; use chrono::prelude::*; use std::{ collections::{HashMap, HashSet}, - sync::mpsc::{channel, Receiver}, - thread::spawn, time::Duration, }; use uuid::Uuid; @@ -45,7 +42,6 @@ impl From for Action { MsgAction::Delete(_) => Action::Delete, MsgAction::Error(_) => Action::Error, MsgAction::GetLog(_) => Action::GetLog, - MsgAction::Log(_) => Action::Log, MsgAction::OnAddition(_) => Action::OnAddition, MsgAction::OnDelete(_) => Action::OnDelete, MsgAction::OnQuery(_) => Action::OnQuery, @@ -75,7 +71,6 @@ pub enum MsgAction { // Remove Error(MTTError), GetLog(Uuid), - Log(Vec), OnAddition(Records), OnDelete(Records), OnQuery(Records), @@ -1691,240 +1686,3 @@ mod oids { } } } - -#[allow(dead_code)] -#[derive(Clone, Debug)] -pub struct MsgEntry { - timestamp: DateTime, - message: Message, -} - -#[allow(dead_code)] -impl MsgEntry { - fn new(msg: Message) -> Self { - Self { - timestamp: Utc::now(), - message: msg, - } - } - - fn get_timestamp(&self) -> &DateTime { - &self.timestamp - } - - fn get_message(&self) -> &Message { - &self.message - } - - fn get_message_id(&self) -> &Uuid { - self.message.get_message_id() - } -} - -#[cfg(test)] -mod msg_entries { - use super::*; - use crate::name::Name; - - #[test] - fn creates_message_entry() { - let msg = Message::new(Name::english("holder"), Query::new()); - let start = Utc::now(); - let entry = MsgEntry::new(msg.clone()); - let end = Utc::now(); - assert!( - entry.get_timestamp() > &start, - "timestamp should be between start and end times" - ); - assert!( - entry.get_timestamp() < &end, - "timestamp should be between start and end times" - ); - assert_eq!(entry.get_message_id(), msg.get_message_id()); - } -} - -#[allow(dead_code)] -#[derive(Clone, Debug)] -struct MsgLogs { - data: HashMap>, -} - -#[allow(dead_code)] -impl MsgLogs { - fn new() -> Self { - Self { - data: HashMap::new(), - } - } - - fn add(&mut self, msg: Message) { - let entry = MsgEntry::new(msg); - let id = entry.get_message_id(); - let entries = match self.data.get_mut(id) { - Some(data) => data, - None => { - self.data.insert(id.clone(), Vec::new()); - self.data.get_mut(id).unwrap() - } - }; - entries.push(entry); - } - - fn get(&self, msg_id: &Uuid) -> Option<&Vec> { - self.data.get(msg_id) - } -} - -#[cfg(test)] -mod msg_logs { - use super::*; - use crate::name::Name; - - #[test] - fn can_add_message_to_log() { - let mut logs = MsgLogs::new(); - let msg = Message::new(Name::english("something"), Query::new()); - logs.add(msg.clone()); - let result = logs.get(msg.get_message_id()).unwrap(); - assert_eq!(result.len(), 1, "should be one entry"); - } - - #[test] - fn returns_none_when_no_logs_found() { - let logs = MsgLogs::new(); - match logs.get(&Uuid::nil()) { - Some(data) => unreachable!("got {:?}, should return none", data), - None => (), - } - } - - #[test] - fn stores_messages_with_responses() { - let mut logs = MsgLogs::new(); - let msg1 = Message::new(Name::english("something"), Query::new()); - let msg2 = msg1.response(Records::new(Names::new())); - logs.add(msg1.clone()); - logs.add(msg2.clone()); - let result = logs.get(msg1.get_message_id()).unwrap(); - assert_eq!(result.len(), 2, "should be two entry"); - let action1: Action = result[0].get_message().get_action().clone().into(); - let action2: Action = result[1].get_message().get_action().clone().into(); - assert_eq!(action1, Action::Query); - assert_eq!(action2, Action::Records); - } - - #[test] - fn messages_are_stored_by_ids() { - let mut logs = MsgLogs::new(); - let msg1 = Message::new(Name::english("something"), Query::new()); - let msg2 = Message::new(Name::english("something"), Query::new()); - logs.add(msg1.clone()); - logs.add(msg2.clone()); - let result1 = logs.get(msg1.get_message_id()).unwrap(); - let result2 = logs.get(msg2.get_message_id()).unwrap(); - assert_eq!(result1.len(), 1, "should be one entry"); - assert_eq!(result2.len(), 1, "should be one entry"); - assert_eq!(result1[0].get_message_id(), msg1.get_message_id()); - assert_eq!(result2[0].get_message_id(), msg2.get_message_id()); - } -} - -#[allow(dead_code)] -struct MessageLog { - data: MsgLogs, - queue: Queue, - rx: Receiver, -} - -#[allow(dead_code)] -impl MessageLog { - fn new(queue: Queue, rx: Receiver) -> Self { - Self { - data: MsgLogs::new(), - queue: queue, - rx: rx, - } - } - - fn start(mut queue: Queue) { - let (tx, rx) = channel(); - let mut logs = MessageLog::new(queue.clone(), rx); - let id = queue.add_sender(tx); - let reg_msg = Register::new( - id, - RegMsg::AddRoute(Path::new(Include::All, Include::All, Include::All)), - ); - let rmsg = Message::new(NameType::None, reg_msg); - queue.send(rmsg.clone()).unwrap(); - spawn(move || { - logs.listen(); - }); - } - - fn listen(&mut self) { - loop { - let msg = self.rx.recv().unwrap(); - match msg.get_action() { - MsgAction::GetLog(id) => match self.data.get(id) { - Some(data) => self - .queue - .send(msg.response(MsgAction::Log(data.clone()))) - .unwrap(), - None => self - .queue - .send(msg.response(MsgAction::Log(Vec::new()))) - .unwrap(), - }, - _ => self.data.add(msg), - } - } - } -} - -#[cfg(test)] -mod message_logs { - use super::*; - use crate::{name::Name, support_tests::TIMEOUT}; - - #[test] - fn does_log_store_messages() { - let doc_name = Name::english("unimportant"); - let mut queue = Queue::new(); - MessageLog::start(queue.clone()); - let (tx, rx) = channel(); - let id = queue.add_sender(tx); - let reg_msg = Register::new(id, RegMsg::AddDocName(vec![doc_name.clone()])); - let rmsg = Message::new(NameType::None, reg_msg); - queue.send(rmsg.clone()).unwrap(); - let name_result = rx.recv().unwrap(); - match name_result.get_action() { - MsgAction::Register(data) => match data.get_msg() { - RegMsg::DocumentNameID(data) => data, - RegMsg::Error(err) => unreachable!("got {:?}, should have gotten data", err), - _ => unreachable!("should only return a name id or an error"), - }, - _ => unreachable!("should only return a name id or an error"), - }; - let request = Register::new( - id.clone(), - RegMsg::AddRoute(Path::new( - Include::All, - Include::All, - Include::Just(Action::Log), - )), - ); - queue.send(Message::new(NameType::None, request)).unwrap(); - rx.recv_timeout(TIMEOUT).unwrap(); - let msg = Message::new(doc_name.clone(), Query::new()); - queue.send(msg.clone()).unwrap(); - let log_msg = Message::new(NameType::None, msg.get_message_id()); - queue.send(log_msg.clone()).unwrap(); - let result = rx.recv_timeout(TIMEOUT).unwrap(); - assert_eq!(result.get_message_id(), log_msg.get_message_id()); - match result.get_action() { - MsgAction::Log(output) => assert_eq!(output.len(), 1), - _ => unreachable!("got {:?}, should have been log", result.get_action()), - } - } -}