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

Updated clock so it can be queried.

Browse Source
This commit is contained in:
Jeff Baskin
2026-05-13 16:47:51 -04:00
parent 8f34bad321
commit bf1942fac8
5 changed files with 151 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/document.rs
View File

@@ -3,7 +3,7 @@ mod create;
mod definition;
mod field;
mod record;
mod session;
// mod session;
use record::{InternalRecord, InternalRecords, Oid};
@@ -12,7 +12,7 @@ pub use create::{CreateDoc, IndexType};
pub use definition::{DocDef, DocFuncType};
pub use field::{Field, FieldType, MissingTranslation};
pub use record::{Record, Records};
pub use session::Session;
//pub use session::Session;
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
enum DocFeature {

168
src/document/clock.rs
View File

@@ -1,29 +1,68 @@
use super::InternalRecord;
use crate::{
action::{Action, MsgAction, Records},
message::Message,
document::record::Oid,
message::{Message, MessageAction},
name::{Name, Names},
queue::{
self,
data_director::{Include, Path, RegMsg, Register},
router::Queue,
},
Query,
};
use chrono::{DateTime, Utc};
use std::{
sync::mpsc::channel,
sync::mpsc::{channel, Receiver},
thread::{sleep, spawn},
time::Duration,
};
pub struct Clock {
struct Pulser {
queue: Queue,
}
impl Clock {
impl Pulser {
fn new(queue: Queue) -> Self {
Self { queue: queue }
}
fn pulse(&self) {
loop {
let msg = Message::new(MsgAction::OnUpdate(Clock::respnse(self.queue.now())));
self.queue.send(msg);
sleep(Duration::from_secs(1));
}
}
}
pub struct Clock {
queue: Queue,
rx: Receiver<Message>,
}
impl Clock {
fn new(queue: Queue, rx: Receiver<Message>) -> Self {
Self {
queue: queue,
rx: rx,
}
}
pub fn doc_names() -> Vec<Name> {
vec![Name::english("clock")]
vec![Name::english("system time")]
}
fn respnse(timestamp: DateTime<Utc>) -> Records {
let mut names = Names::new();
let field_name = Name::english("time");
names.add_names(vec![field_name.clone()]);
let field_id = names.get_id(field_name).unwrap();
let mut recs = Records::new(Self::doc_names(), names);
let mut rec = InternalRecord::new();
rec.insert(field_id, timestamp);
recs.insert(Oid::new(), rec);
recs
}
pub fn gen_message() -> Message {
@@ -33,22 +72,22 @@ impl Clock {
)))
}
pub fn get_path() -> Path {
Path::new(
Include::All,
Include::Just(Clock::doc_names()[0].clone().into()),
Include::Just(Action::OnUpdate),
)
}
pub fn start(mut queue: Queue) {
let clock = Clock::new(queue.clone());
let pulser = Pulser::new(queue.clone());
spawn(move || {
pulser.pulse();
});
let (tx, rx) = channel();
let id = queue.add_sender(tx);
let reg_msg = Register::new(id, RegMsg::AddDocName(Clock::doc_names()));
let msg = Message::new(reg_msg.clone());
queue.send(msg);
rx.recv().unwrap();
let path = Path::new(
Include::All,
Include::Just(Clock::doc_names()[0].clone().into()),
Include::Just(Action::Query),
);
let reg_msg = Register::new(id.clone(), RegMsg::AddRoute(path.clone()));
queue.send(Message::new(reg_msg));
rx.recv().unwrap(); // Wait for completion.
let clock = Clock::new(queue.clone(), rx);
spawn(move || {
clock.listen();
});
@@ -56,8 +95,9 @@ impl Clock {
fn listen(&self) {
loop {
self.queue.send(Clock::gen_message());
sleep(Duration::from_secs(1));
let msg = self.rx.recv().unwrap();
let reply = msg.set_action(Clock::respnse(self.queue.now()));
self.queue.send(reply);
}
}
}
@@ -65,18 +105,61 @@ impl Clock {
#[cfg(test)]
mod clocks {
use super::*;
use crate::queue::{
data_director::{Include, Path},
router::TestClock,
use crate::{
queue::{
self,
data_director::{Include, Path},
TestClock,
},
Field, NameType,
};
use chrono::{TimeDelta, Utc};
static TIMEOUT: Duration = Duration::from_millis(1500);
#[test]
fn does_clock_send_reply_every_second() {
fn can_document_names_be_returned() {
let doc_names = vec![Name::english("system time")];
assert_eq!(Clock::doc_names(), doc_names);
}
#[test]
fn can_return_time_record() {
let now = Utc::now();
let recs = Clock::respnse(now.clone());
assert_eq!(recs.doc_name(), &Clock::doc_names()[0].clone().into());
assert_eq!(recs.len(), 1, "received: {:?}", recs);
let rec = recs.iter().last().unwrap();
assert_eq!(rec.get(Name::english("time")).unwrap(), now.into());
}
#[test]
fn does_clock_update_return_correct_time() {
let clock = TestClock::new();
let mut queue = Queue::with_clock(clock);
let mut queue = Queue::with_clock(clock.clone());
let expected: Field = queue.now().into();
let (tx, rx) = channel();
let id = queue.add_sender(tx);
let request = Register::new(
id.clone(),
RegMsg::AddRoute(Path::new(Include::All, Include::All, Include::All)),
);
queue.send(Message::new(request));
rx.recv_timeout(TIMEOUT).unwrap();
Clock::start(queue.clone());
let result = rx.recv_timeout(TIMEOUT).unwrap();
match result.get_action() {
MsgAction::OnUpdate(data) => {
let rec = data.iter().last().unwrap();
assert_eq!(rec.get(Name::english("time")).unwrap(), expected);
}
_ => unreachable!("should return on_update: {:?}", result.get_action()),
}
}
#[test]
fn does_clock_send_reply_every_second() {
let mut queue = Queue::new();
let (tx, rx) = channel();
let id = queue.add_sender(tx);
let request = Register::new(
@@ -94,15 +177,36 @@ mod clocks {
let end = Utc::now();
assert!((end - start) > TimeDelta::seconds(1));
assert!((end - start) < TimeDelta::seconds(2));
let reg_request = Register::new(id, RegMsg::GetNameID(Clock::doc_names()[0].clone()));
queue.send(Message::new(reg_request));
}
#[test]
fn can_time_be_queried() {
let clock = TestClock::new();
let mut queue = Queue::with_clock(clock.clone());
let expected: Field = queue.now().into();
let (tx, rx) = channel();
let id = queue.add_sender(tx);
let request = Register::new(
id.clone(),
RegMsg::AddRoute(Path::new(
Include::All,
Include::Just(Clock::doc_names()[0].clone().into()),
Include::Just(Action::Records),
)),
);
queue.send(Message::new(request));
rx.recv_timeout(TIMEOUT).unwrap();
for msg in holder.iter() {
let action = msg.get_action();
match action {
MsgAction::OnUpdate(result) => assert_eq!(result.len(), 0),
_ => unreachable!("got {:?}, should have been empty record", action),
Clock::start(queue.clone());
let msg = Message::new(Query::new(Clock::doc_names()[0].clone()));
queue.send(msg.clone());
let result = rx.recv_timeout(TIMEOUT).unwrap();
assert_eq!(result.get_message_id(), msg.get_message_id());
match result.get_action() {
MsgAction::Records(data) => {
let rec = data.iter().last().unwrap();
assert_eq!(rec.get(Name::english("time")).unwrap(), expected);
}
_ => unreachable!("should return on_update: {:?}", result.get_action()),
}
}
}

10
src/document/create.rs
View File

@@ -1,4 +1,4 @@
use super::Session;
//use super::Session;
use super::{DocFeature, InternalRecord, InternalRecords, Oid};
use crate::{
action::{Action, CalcValue, Calculation, MsgAction, Query, Records, Reply, Update},
@@ -451,12 +451,15 @@ impl DocumentFile {
}
fn listen(&mut self) {
let sess_name = Session::doc_names()[0].clone();
//let sess_name = Session::doc_names()[0].clone();
loop {
let msg = self.rx.recv().unwrap();
/*
* references old session.
if !self.docdef.has_feature(&DocFeature::System) {
self.queue.send(Message::new(Query::new(sess_name.clone())));
}
*/
let route = msg.get_route();
for (route_id, doc_func) in self.routes.clone().iter() {
if route == route_id.into() {
@@ -791,6 +794,8 @@ mod internal_features {
use crate::{Name, TestMoreThanText};
use std::sync::mpsc::RecvTimeoutError;
/*
* references old sessions
#[test]
fn do_system_documents_ignores_session() {
let sess_name = Session::doc_names()[0].clone();
@@ -815,4 +820,5 @@ mod internal_features {
},
}
}
*/
}

5
src/queue/data_director/engine.rs
View File

@@ -1,6 +1,7 @@
use super::super::SenderID;
use crate::{
action::{Action, Field, MsgAction},
document::Clock,
message::{Message, MessageAction, MessageID},
mtterror::MTTError,
name::{Name, NameID, NameType, Names},
@@ -760,8 +761,10 @@ pub struct DocRegistry {
impl DocRegistry {
fn new(queue: Queue, rx: Receiver<Message>) -> Self {
let mut doc_names = Names::new();
doc_names.add_names(Clock::doc_names());
Self {
doc_names: Names::new(),
doc_names: doc_names,
queue: queue.clone(),
receiver: rx,
routes: RouteStorage::new(),