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

Got session control into it's own layer.

Browse Source
This commit is contained in:
Jeff Baskin
2025-04-21 21:44:52 -04:00
parent 4fc050e590
commit 393b66a9f5
6 changed files with 168 additions and 369 deletions
Download Patch File Download Diff File Expand all files Collapse all files

406
src/client.rs
View File

@ -15,373 +15,165 @@ use uuid::Uuid;
const RESPONS_TO: [MsgType; 2] = [MsgType::Document, MsgType::SessionValidated];
pub struct Request {
pub session: Option<Field>,
}
impl Request {
pub fn new(session: Option<Field>) -> Self {
Self { session: session }
}
}
#[cfg(test)]
pub mod requests {
use super::*;
pub fn get_root_document() -> Request {
Request::new(None)
}
pub fn get_root_with_session(sess_id: &Uuid) -> Request {
Request::new(Some(sess_id.clone().into()))
}
pub fn get_root_document_eith_session<F>(id: F) -> Request
where
F: Into<Field>,
{
Request::new(Some(id.into()))
}
#[test]
fn new_request_no_session() {
let sess: Option<Field> = None;
let req = Request::new(sess);
assert!(req.session.is_none(), "should not have a session")
}
#[test]
fn new_request_with_session() {
let id = Uuid::new_v4();
let req = Request::new(Some(id.into()));
match req.session {
Some(result) => assert_eq!(result.to_uuid().unwrap(), id),
None => unreachable!("should contain a session"),
}
}
}
pub struct Reply {
sess_id: Uuid,
content: String,
}
impl Reply {
fn new(sess_id: Uuid, content: String) -> Self {
Self {
sess_id: sess_id,
content: content,
}
}
pub fn get_session(&self) -> Uuid {
self.sess_id.clone()
}
pub fn get_content(&self) -> String {
self.content.clone()
}
}
#[cfg(test)]
mod replies {
use super::*;
pub fn create_reply() -> Reply {
Reply {
sess_id: Uuid::new_v4(),
content: "some text".to_string(),
}
}
#[test]
fn create_new_reply() {
let sess_id = Uuid::new_v4();
let txt = Uuid::new_v4().to_string();
let reply = Reply::new(sess_id, txt.clone());
assert_eq!(reply.get_session(), sess_id);
assert_eq!(reply.get_content(), txt);
}
}
#[derive(Clone)]
pub struct ClientRegistry {
pub struct ClientChannel {
queue: Queue,
registry: Arc<Mutex<HashMap<Uuid, Sender<Message>>>>,
}
impl ClientRegistry {
pub fn new() -> Self {
impl ClientChannel {
fn new(queue: Queue) -> Self {
Self {
queue: queue,
registry: Arc::new(Mutex::new(HashMap::new())),
}
}
fn get_id<'a>(
gen: &mut impl Iterator<Item = Uuid>,
data: &HashMap<Uuid, Sender<Message>>,
) -> Uuid {
let mut id = gen.next().unwrap();
while data.contains_key(&id) {
id = gen.next().unwrap();
}
id.clone()
}
pub fn add(&mut self, tx: Sender<Message>) -> Uuid {
pub fn send(&self, mut msg: Message) -> Receiver<Message> {
let mut reg = self.registry.lock().unwrap();
let mut gen_id = GenID::new();
let id = ClientRegistry::get_id(&mut gen_id, &reg);
reg.insert(id.clone(), tx);
id
}
fn send(&mut self, id: &Uuid, msg: Message) {
let mut reg = self.registry.lock().unwrap();
let tx = reg.remove(id).unwrap();
tx.send(msg).unwrap();
}
}
#[cfg(test)]
mod clientregistries {
use super::*;
use crate::client::replies::create_reply;
use std::{
sync::mpsc::{channel, Receiver},
time::Duration,
};
static TIMEOUT: Duration = Duration::from_millis(500);
#[test]
fn create_client_registry() {
let reg = ClientRegistry::new();
let data = reg.registry.lock().unwrap();
assert!(data.is_empty(), "needs to create an empty hashmap");
}
#[test]
fn send_from_client() {
let mut reg = ClientRegistry::new();
let count = 10;
let mut rxs: HashMap<Uuid, Receiver<Message>> = HashMap::new();
for _ in 0..count {
let (tx, rx) = channel::<Message>();
let id = reg.add(tx);
rxs.insert(id, rx);
if reg.contains_key(&msg.get_id()) {
let mut id = Uuid::new_v4();
while reg.contains_key(&id) {
id = Uuid::new_v4();
}
msg.reset_id(id);
}
assert_eq!(rxs.len(), count, "should have been {} receivers", count);
for (id, rx) in rxs.iter() {
let msg = Message::new(MsgType::Document);
reg.send(id, msg);
rx.recv_timeout(TIMEOUT).unwrap();
}
let data = reg.registry.lock().unwrap();
assert!(data.is_empty(), "should remove sender after sending");
}
#[test]
fn prevent_duplicates() {
let mut reg = ClientRegistry::new();
let (tx, _rx) = channel::<Message>();
let existing = reg.add(tx);
let expected = Uuid::new_v4();
let ids = [existing.clone(), expected.clone()];
let data = reg.registry.lock().unwrap();
let result = ClientRegistry::get_id(&mut ids.into_iter(), &data);
assert_eq!(result, expected);
}
}
#[derive(Clone)]
pub struct ClientLink {
tx: Sender<Message>,
registry: ClientRegistry,
}
impl ClientLink {
fn new(tx: Sender<Message>, registry: ClientRegistry) -> Self {
Self {
tx: tx,
registry: registry,
}
}
pub fn send(&mut self, mut req: Message) -> Receiver<Message> {
let (tx, rx) = channel();
//let mut msg: Message = req.into();
let id = self.registry.add(tx);
req.add_data("tx_id", id);
self.tx.send(req).unwrap();
reg.insert(msg.get_id(), tx);
self.queue.send(msg);
rx
}
fn reply(&self, msg: Message) {
let mut reg = self.registry.lock().unwrap();
match reg.remove(&msg.get_id()) {
Some(tx) => tx.send(msg).unwrap(),
None => {}
}
}
}
#[cfg(test)]
mod clientlinks {
mod client_channels {
use super::*;
use crate::client::replies::create_reply;
use std::time::Duration;
static TIMEOUT: Duration = Duration::from_millis(500);
#[test]
fn create_client_link() {
fn request_new_message() {
let queue = Queue::new();
let chan = ClientChannel::new(queue);
let msg_types = [MsgType::Document, MsgType::Time];
for msg_type in msg_types.iter() {
let msg = Message::new(msg_type.clone());
assert_eq!(msg.get_msg_type(), msg_type);
}
}
#[test]
fn fowards_message() {
let msg_type = MsgType::Document;
let reply_type = MsgType::Time;
let queue = Queue::new();
let (tx, rx) = channel();
let mut registry = ClientRegistry::new();
let mut link = ClientLink::new(tx, registry.clone());
let req = Request::new(None);
let rx_client = link.send(req.into());
let msg = rx.recv_timeout(TIMEOUT).unwrap();
match msg.get_msg_type() {
MsgType::ClientRequest => {}
_ => unreachable!("should have been a client request"),
}
match msg.get_data("tx_id") {
Some(result) => {
let id = result.to_uuid().unwrap();
registry.send(&id, msg.reply(MsgType::Document));
rx_client.recv().unwrap();
}
None => unreachable!("should have had a seender id"),
}
queue.add(tx, [msg_type.clone()].to_vec());
let chan = ClientChannel::new(queue);
let msg = Message::new(msg_type.clone());
let client_rx = chan.send(msg.clone());
let reply = rx.recv_timeout(TIMEOUT).unwrap();
assert_eq!(reply.get_id(), msg.get_id());
assert_eq!(reply.get_msg_type().clone(), msg_type);
let client_reply = reply.reply(MsgType::Time);
chan.reply(client_reply);
let client_msg = client_rx.recv_timeout(TIMEOUT).unwrap();
assert_eq!(client_msg.get_id(), msg.get_id());
assert_eq!(client_msg.get_msg_type().clone(), reply_type);
}
#[test]
fn no_duplicate_ids() {
let (tx, rx) = channel();
let queue = Queue::new();
queue.add(tx, [MsgType::Time].to_vec());
let chan = ClientChannel::new(queue);
let msg1 = Message::new(MsgType::Time);
let msg2 = msg1.reply(MsgType::Time);
let rx1 = chan.send(msg1);
let rx2 = chan.send(msg2);
let queue1 = rx.recv_timeout(TIMEOUT).unwrap();
let queue2 = rx.recv_timeout(TIMEOUT).unwrap();
assert_ne!(queue1.get_id(), queue2.get_id());
chan.reply(queue1.reply(MsgType::Document));
chan.reply(queue2.reply(MsgType::Document));
let reply1 = rx1.recv_timeout(TIMEOUT).unwrap();
let reply2 = rx2.recv_timeout(TIMEOUT).unwrap();
assert_eq!(reply1.get_id(), queue1.get_id());
assert_eq!(reply2.get_id(), queue2.get_id());
}
#[test]
fn ignore_unrequested() {
let queue = Queue::new();
let chan = ClientChannel::new(queue);
chan.reply(Message::new(MsgType::Document));
}
}
pub struct Client {
channel: ClientChannel,
queue: Queue,
registry: ClientRegistry,
return_to: HashMap<Uuid, Message>,
rx: Receiver<Message>,
}
impl Client {
fn new(rx: Receiver<Message>, queue: Queue) -> Self {
fn new(chan: ClientChannel, queue: Queue, rx: Receiver<Message>) -> Self {
Self {
channel: chan,
queue: queue,
registry: ClientRegistry::new(),
return_to: HashMap::new(),
rx: rx,
}
}
pub fn start(queue: Queue) -> ClientLink {
pub fn start(queue: Queue) -> ClientChannel {
let (tx, rx) = channel();
queue.add(tx.clone(), RESPONS_TO.to_vec());
let mut client = Client::new(rx, queue);
let link = ClientLink::new(tx, client.get_registry());
let chan = ClientChannel::new(queue.clone());
let client = Client::new(chan.clone(), queue, rx);
spawn(move || {
client.listen();
});
link
chan
}
fn listen(&mut self) {
fn listen(&self) {
loop {
let msg = self.rx.recv().unwrap();
match msg.get_msg_type() {
MsgType::ClientRequest => self.client_request(msg),
MsgType::Document => self.document(msg),
MsgType::SessionValidated => self.session(msg),
_ => unreachable!("Received message it did not understand"),
}
self.channel.reply(msg);
}
}
fn get_registry(&self) -> ClientRegistry {
self.registry.clone()
}
fn client_request(&mut self, msg: Message) {
self.return_to.insert(msg.get_id(), msg.clone());
let mut reply = msg.reply(MsgType::SessionValidate);
match msg.get_data("sess_id") {
Some(sess_id) => reply.add_data("sess_id", sess_id.clone()),
None => {}
}
self.queue.send(reply).unwrap();
}
fn session(&mut self, msg: Message) {
let initial_msg = self.return_to.get_mut(&msg.get_id()).unwrap();
let mut reply = msg.reply(MsgType::DocumentRequest);
match msg.get_data("sess_id") {
Some(sess_id) => {
initial_msg.add_data("sess_id", sess_id.clone());
reply.add_data("sess_id", sess_id.clone());
}
None => unreachable!("validated should always have an id"),
}
self.queue.send(reply).unwrap();
}
fn document(&mut self, msg: Message) {
let initial_msg = self.return_to.remove(&msg.get_id()).unwrap();
let tx_id = initial_msg.get_data("tx_id").unwrap().to_uuid().unwrap();
/*
let reply = Reply::new(
initial_msg.get_data("sess_id").unwrap().to_uuid().unwrap(),
msg.get_data("doc").unwrap().to_string(),
)s
*/
self.registry
.send(&tx_id, initial_msg.reply(MsgType::Document));
}
}
#[cfg(test)]
mod clients {
use super::*;
use requests::get_root_with_session;
use crate::session::sessions::create_validated_reply;
use std::time::Duration;
static TIMEOUT: Duration = Duration::from_millis(500);
/*
#[test]
fn start_client() {
let sess_id1 = Uuid::new_v4();
let sess_id2 = Uuid::new_v4();
let doc = Uuid::new_v4().to_string();
let (tx, rx) = channel();
fn session_validated() {
let queue = Queue::new();
queue.add(
tx,
[MsgType::SessionValidate, MsgType::DocumentRequest].to_vec(),
);
let mut link = Client::start(queue.clone());
let req = get_root_with_session(&sess_id1);
let reply_rx = link.send(req.into());
let send1 = rx.recv_timeout(TIMEOUT).unwrap();
match send1.get_msg_type() {
MsgType::SessionValidate => {}
_ => unreachable!("should request session validation"),
}
assert_eq!(
send1.get_data("sess_id").unwrap().to_uuid().unwrap(),
sess_id1
);
assert!(send1.get_data("tx_id").is_none());
let mut response = send1.reply_with_data(MsgType::SessionValidated);
response.add_data("sess_id", sess_id2);
queue.send(response).unwrap();
let send2 = rx.recv_timeout(TIMEOUT).unwrap();
assert_eq!(send2.get_id(), send1.get_id());
match send2.get_msg_type() {
MsgType::DocumentRequest => {}
_ => unreachable!("should request session validation"),
}
assert_eq!(
send2.get_data("sess_id").unwrap().to_uuid().unwrap(),
sess_id2
);
let mut document = send2.reply(MsgType::Document);
document.add_data("doc", doc.clone());
queue.send(document).unwrap();
let reply = reply_rx.recv_timeout(TIMEOUT).unwrap();
assert_eq!(reply.get_data("sess_id").unwrap().to_uuid().unwrap(), sess_id2);
assert_eq!(reply.get_data("doc").unwrap().to_string(), doc);
let (queue_tx, queue_rx) = channel();
queue.add(queue_tx, [MsgType::SessionValidate].to_vec());
let chan = Client::start(queue.clone());
let chan_rx = chan.send(Message::new(MsgType::SessionValidate));
let msg = queue_rx.recv_timeout(TIMEOUT).unwrap();
let expected = create_validated_reply(msg);
queue.send(expected.clone());
let result = chan_rx.recv_timeout(TIMEOUT).unwrap();
assert_eq!(result.get_id(), expected.get_id());
assert_eq!(result.get_msg_type(), expected.get_msg_type());
}
*/
}