Removed logging code for now.

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<MsgAction> 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<MsgEntry>),
     OnAddition(Records),
     OnDelete(Records),
     OnQuery(Records),
@@ -1691,240 +1686,3 @@ mod oids {
         }
     }
 }
-
-#[allow(dead_code)]
-#[derive(Clone, Debug)]
-pub struct MsgEntry {
-    timestamp: DateTime<Utc>,
-    message: Message,
-}
-
-#[allow(dead_code)]
-impl MsgEntry {
-    fn new(msg: Message) -> Self {
-        Self {
-            timestamp: Utc::now(),
-            message: msg,
-        }
-    }
-
-    fn get_timestamp(&self) -> &DateTime<Utc> {
-        &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<Uuid, Vec<MsgEntry>>,
-}
-
-#[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<MsgEntry>> {
-        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<Message>,
-}
-
-#[allow(dead_code)]
-impl MessageLog {
-    fn new(queue: Queue, rx: Receiver<Message>) -> 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()),
-        }
-    }
-}