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"),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|