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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

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

use super::{Request, Status};
use crate::simulation::routing::RequestData;
use crate::MinQueue;

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

// Setup logic
impl Queue {
    pub fn new() -> Self {
        Self {
            inner: vec![],
            enqueued: MinQueue::new(),
            waiting: HashMap::new(),
        }
    }
    pub fn push(&mut self, req: Request) {
        let req = Rc::new(RefCell::new(req));

        self.inner.push(req);
    }

    // Assign all of the requests into the queue to be released
    pub fn init(&mut self) {
        for req in &self.inner {
            self.enqueued.push(req.clone());
        }
    }
}

// Ticking logic
impl Queue {
    pub fn tick(&mut self, tick: Duration) {
        // First tick the already waiting items, they cannot be assigned if they are already over
        // their waiting limit.
        self.tick_queued(tick);
        // ...then release new items to the waiting queue to be assigned.
        self.tick_release_to_queue(tick);
    }

    fn tick_queued(&mut self, tick: Duration) {
        self.waiting.retain(|_, (request, _)| {
            let mut request = request.borrow_mut();
            request.tick_wait(tick);
            &Status::Enqueued == request.status()
        });
    }

    fn tick_release_to_queue(&mut self, tick: Duration) {
        while self
            .enqueued
            .peek()
            .map_or(Duration::MAX, |c| c.borrow().start())
            <= tick
        {
            let next_request = self
                .enqueued
                .pop()
                .expect("Request was peeked and should have been popped");

            let mut request = next_request.borrow_mut();
            request.enqueue(tick);

            let routing_data = RequestData::from(&*request);

            self.waiting
                .insert(request.id(), (next_request.clone(), routing_data));
        }
    }

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

// Misc
impl Queue {
    pub fn requests(&self) -> &Vec<Rc<RefCell<Request>>> {
        &self.inner
    }

    pub fn has_waiting(&self) -> bool {
        !self.waiting.is_empty()
    }

    pub fn routing_data(&self) -> Vec<&RequestData> {
        self.waiting.values().map(|(_, r)| r).collect()
    }

    pub fn handle_request(&mut self, id: usize, tick: Duration) -> Duration {
        // TODO: This is not safe since id might not exist
        let mut request = self
            .waiting
            .get(&id)
            .expect("Client Id does not exist")
            .0
            .borrow_mut();

        request.handle(tick)
    }
}