MoreThanText/morethantext
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Removed logging code for now.
Some checks failed
Gitea Actions Demo / Explore-Gitea-Actions (push) Failing after 1s
Details

Browse Source
This commit is contained in:
Jeff Baskin 2026-01-26 14:31:37 -05:00
parent 102e60bf94
commit b2bd142b22
1 changed files with 1 additions and 243 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

244
src/message.rs
View File

@ -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()),
}
}
}