awt 0.1.0

A simulation engine which can emulate a client/server with multiple requests.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

use core::time::Duration;
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;

use super::QueueableServer;
use crate::simulation::routing::ServerData;
use crate::MinQueue;

pub struct Queue {
    inner: Vec<Rc<RefCell<QueueableServer>>>,
    enqueued: MinQueue<Rc<RefCell<QueueableServer>>>,
    waiting: HashMap<usize, (Rc<RefCell<QueueableServer>>, ServerData)>,
}

// Setup and cretion logic
impl Queue {
    pub fn new() -> Self {
        Self {
            inner: vec![],
            enqueued: MinQueue::new(),
            waiting: HashMap::new(),
        }
    }

    pub fn push(&mut self, server: QueueableServer) {
        let server = Rc::new(RefCell::new(server));

        self.inner.push(server);
    }

    pub fn init(&mut self) {
        for server in &self.inner {
            let routing_data = ServerData::from(server.borrow().server());
            self.waiting.insert(
                server.borrow().server().id(),
                (server.clone(), routing_data),
            );
        }
    }
}

// Logic relevant for progressing and selecting items from the queue
impl Queue {
    pub fn tick(&mut self, tick: Duration) {
        while self
            .enqueued
            .peek()
            .map_or(Duration::MAX, |s| s.borrow().tick)
            <= tick
        {
            let next_server = self
                .enqueued
                .pop()
                .expect("Server was peeked and should have popped");

            let routing_data = ServerData::from(next_server.borrow().server());

            self.waiting.insert(
                next_server.borrow().server().id(),
                (next_server.clone(), routing_data),
            );
        }
    }

    pub fn next_tick(&self) -> Option<Duration> {
        self.enqueued.peek().map(|c| c.borrow().tick)
    }
}

// Misc
impl Queue {
    pub fn routing_data(&self) -> Vec<&ServerData> {
        self.waiting.values().map(|(_, s)| s).collect()
    }

    pub fn enqueue(&mut self, id: usize, until: Duration) {
        // TODO: Safely chceck that the server_queue has this server_id
        let (server, _) = self
            .waiting
            .remove(&id)
            .expect("Server Id should have been queued");

        server.borrow_mut().tick = until;

        self.enqueued.push(server);
    }
}