From d824220fabb46dd688985e7fee2f194a490b448b Mon Sep 17 00:00:00 2001 From: Jeff Baskin Date: Sun, 2 Mar 2025 10:36:03 -0500 Subject: [PATCH] Added backend. --- src/backend.rs | 50 +++++++++++++++++++++++++++++++++++++++++++++++++ src/frontend.rs | 32 +++++++++++++------------------ src/lib.rs | 3 ++- src/queue.rs | 18 +++++------------- src/session2.rs | 47 ++++++++++++++++++---------------------------- 5 files changed, 88 insertions(+), 62 deletions(-) create mode 100644 src/backend.rs diff --git a/src/backend.rs b/src/backend.rs new file mode 100644 index 0000000..a5460d6 --- /dev/null +++ b/src/backend.rs @@ -0,0 +1,50 @@ +use crate::queue::Message; +use std::{ + sync::mpsc::{channel, Receiver, Sender}, + thread::spawn, +}; + +struct BackEnd { + tx: Sender, + rx: Receiver, +} + +impl BackEnd { + fn new(tx: Sender, rx: Receiver) -> Self { + Self { + tx: tx, + rx: rx, + } + } + + fn start(queue_tx: Sender) { + spawn(move || { + let (tx, rx) = channel(); + let service = Self::new(queue_tx.clone(), rx); + queue_tx.send(tx.clone().into()).unwrap(); + service.listen(); + }); + } + + fn listen(&self) { + loop { + self.rx.recv().unwrap(); + } + } +} + +#[cfg(test)] +mod backends { + use std::time::Duration; + use super::*; + + #[test] + fn get_registered() { + let (tx, rx) = channel(); + BackEnd::start(tx); + match rx.recv_timeout(Duration::from_millis(500)).unwrap() { + Message::Register(_) => {}, + _ => unreachable!("should register the service"), + } + } +} diff --git a/src/frontend.rs b/src/frontend.rs index 296904e..031375c 100644 --- a/src/frontend.rs +++ b/src/frontend.rs @@ -1,9 +1,4 @@ -use crate::{ - Field, - Request, - queue::Message, - session2::SessionMessage, -}; +use crate::{queue::Message, session2::SessionMessage, Field, Request}; use std::{ sync::mpsc::{channel, Receiver, Sender}, thread::spawn, @@ -16,10 +11,7 @@ struct FrontEnd { impl FrontEnd { fn new(tx: Sender, rx: Receiver) -> Self { - Self { - tx: tx, - rx: rx, - } + Self { tx: tx, rx: rx } } fn start(queue_tx: Sender) { @@ -43,9 +35,11 @@ impl FrontEnd { #[cfg(test)] mod frontends { - use crate::create_request::empty_request; - use std::time::Duration; use super::*; + use crate::{ + create_request::empty_request, session2::create_session_message::create_session_new, + }; + use std::time::Duration; fn run_service() -> (Sender, Receiver) { let (tx, rx) = channel(); @@ -63,8 +57,7 @@ mod frontends { let (tx, rx) = channel(); FrontEnd::start(tx); match rx.recv().unwrap() { - Message::Register(_) => { - }, + Message::Register(_) => {} _ => unreachable!("should register the service"), } } @@ -75,13 +68,14 @@ mod frontends { let (req, _) = empty_request(); tx.send(req.into()).unwrap(); match rx.recv_timeout(Duration::from_millis(500)).unwrap() { - Message::SessMsg(output) => { - match output { - SessionMessage::Validate(result) => assert!(result.is_none()), - _ => unreachable!("Should have sent a val9idate"), - } + Message::SessMsg(output) => match output { + SessionMessage::Validate(result) => assert!(result.is_none()), + _ => unreachable!("Should have sent a val9idate"), }, _ => unreachable!("Should have generated a session message"), } + let (new_sess, sess_id) = create_session_new(); + tx.send(new_sess.into()).unwrap(); + // generate backend request. } } diff --git a/src/lib.rs b/src/lib.rs index 6cbd473..9c591c0 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,3 +1,4 @@ +mod backend; mod client; mod data; mod error; @@ -468,7 +469,7 @@ impl MoreThanText { * tx = Queue::start(); * tx.send(Session::start().into()).unwrap(); * Self { tx: tx } - */ + */ let (tx, rx) = channel(); let mut senders = Vec::new(); senders.push(Client::start(tx.clone())); diff --git a/src/queue.rs b/src/queue.rs index 511f94a..6c69303 100644 --- a/src/queue.rs +++ b/src/queue.rs @@ -1,7 +1,4 @@ -use crate::{ - Request, - session2::SessionMessage, -}; +use crate::{session2::SessionMessage, Request}; use std::{ sync::mpsc::{channel, Receiver, Sender}, thread::spawn, @@ -35,10 +32,7 @@ impl From for Message { #[cfg(test)] mod messages { use super::*; - use crate::{ - create_request::empty_request, - Field, - }; + use crate::{create_request::empty_request, Field}; #[test] fn from_request() { @@ -70,11 +64,9 @@ mod messages { let id: Option = None; let sess_msg: SessionMessage = id.into(); match sess_msg.into() { - Message::SessMsg(result) => { - match result { - SessionMessage::Validate(data) => assert!(data.is_none()), - _ => unreachable!("should have been a validate"), - } + Message::SessMsg(result) => match result { + SessionMessage::Validate(data) => assert!(data.is_none()), + _ => unreachable!("should have been a validate"), }, _ => unreachable!("should have been a session message"), } diff --git a/src/session2.rs b/src/session2.rs index aced773..dc2e4e5 100644 --- a/src/session2.rs +++ b/src/session2.rs @@ -1,7 +1,4 @@ -use crate::{ - Field, - queue::Message, -}; +use crate::{queue::Message, Field}; use std::{ sync::mpsc::{channel, Receiver, Sender}, thread::spawn, @@ -10,7 +7,7 @@ use uuid::Uuid; #[derive(Clone)] pub enum SessionMessage { - New(Field), + New(Field), Validate(Option), } @@ -21,11 +18,12 @@ impl From> for SessionMessage { } #[cfg(test)] -pub mod crete_session_message { +pub mod create_session_message { use super::*; - fn create_session_new() -> SessionMessage { - SessionMessage::New(Uuid::new_v4().into()) + pub fn create_session_new() -> (SessionMessage, Uuid) { + let id = Uuid::new_v4(); + (SessionMessage::New(id.into()), id) } } @@ -38,16 +36,12 @@ mod sessionmessages { let text = "afield"; let id = Some(text.into()); match id.into() { - SessionMessage::Validate(result) => { - match result { - Some(data) => { - match data { - Field::Static(output) => assert_eq!(output, text), - _ => unreachable!("should have returned static text"), - } - }, - None => unreachable!("shoulf have returned data"), - } + SessionMessage::Validate(result) => match result { + Some(data) => match data { + Field::Static(output) => assert_eq!(output, text), + _ => unreachable!("should have returned static text"), + }, + None => unreachable!("shoulf have returned data"), }, _ => unreachable!("should have been a vaqlidate"), } @@ -61,10 +55,7 @@ struct Session { impl Session { fn new(tx: Sender, rx: Receiver) -> Self { - Self { - tx: tx, - rx: rx, - } + Self { tx: tx, rx: rx } } fn start(queue_tx: Sender) { @@ -87,15 +78,15 @@ impl Session { #[cfg(test)] mod sessions { - use std::time::Duration; use super::*; + use std::time::Duration; #[test] fn gets_registered() { let (tx, rx) = channel(); Session::start(tx); match rx.recv().unwrap() { - Message::Register(_) => {}, + Message::Register(_) => {} _ => unreachable!("should register the service"), } } @@ -113,11 +104,9 @@ mod sessions { let req: SessionMessage = data.into(); sender.send(req.into()).unwrap(); match rx.recv_timeout(Duration::from_millis(500)).unwrap() { - Message::SessMsg(data) => { - match data { - SessionMessage::New(_) => {}, - _ => unreachable!("should have been a new session"), - } + Message::SessMsg(data) => match data { + SessionMessage::New(_) => {} + _ => unreachable!("should have been a new session"), }, _ => unreachable!("should have been a session message response"), }