118 lines
2.7 KiB
Rust
Raw Normal View History

2025-02-22 10:53:05 -05:00
use crate::Request;
use std::{
sync::mpsc::{channel, Receiver, Sender},
thread::spawn,
};
#[derive(Clone)]
enum Message {
Register(Sender<Message>),
Req(Request),
}
impl From<Request> for Message {
fn from(value: Request) -> Self {
Message::Req(value)
}
}
impl From<Sender<Message>> for Message {
fn from(value: Sender<Message>) -> Self {
Message::Register(value)
}
}
#[cfg(test)]
mod messages {
use super::*;
use crate::create_request::empty_request;
#[test]
fn from_request() {
let (req, _) = empty_request();
match req.into() {
Message::Req(result) => assert!(result.get_session().is_none()),
_ => unreachable!("should have been s request"),
}
}
#[test]
fn from_sender() {
2025-02-22 11:09:47 -05:00
let (tx, rx) = channel();
2025-02-22 10:53:05 -05:00
match tx.into() {
2025-02-22 11:09:47 -05:00
Message::Register(result) => {
let (req, _) = empty_request();
result.send(req.into()).unwrap();
match rx.recv().unwrap() {
Message::Req(_) => {}
_ => unreachable!("should have been a request"),
}
}
2025-02-22 10:53:05 -05:00
_ => unreachable!("should have been a register"),
}
}
}
struct Queue {
channels: Vec<Sender<Message>>,
rx: Receiver<Message>,
}
impl Queue {
fn new(rx: Receiver<Message>) -> Self {
Self {
channels: Vec::new(),
rx: rx,
}
}
fn listen(&mut self) {
loop {
let msg = self.rx.recv().unwrap();
match msg {
Message::Register(tx) => self.channels.push(tx),
_ => {
for tx in self.channels.iter() {
tx.send(msg.clone()).unwrap();
}
}
}
}
}
fn start() -> Sender<Message> {
let (tx, rx) = channel();
spawn(move || {
let mut queue = Queue::new(rx);
queue.listen();
});
tx
}
}
#[cfg(test)]
mod queues {
use super::*;
use crate::create_request::empty_request;
#[test]
fn create_queue() {
let mut channels = Vec::new();
for _ in 0..5 {
channels.push(channel());
}
let mut queue_tx = Queue::start();
for (tx, _) in channels.iter() {
queue_tx.send(tx.clone().into()).unwrap();
}
let (req, _) = empty_request();
queue_tx.send(req.into()).unwrap();
for (_, rx) in channels.iter() {
match rx.recv().unwrap() {
Message::Req(_) => {}
_ => unreachable!("should have been a request"),
}
}
}
}