romp 0.5.2

STOMP server and WebSockets platform
Documentation 
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

//! `heart-beat` functions.

use std::sync::{Arc, RwLock};

use log::*;

use crate::init::CONFIG;

use crate::message::stomp_message::{Header, StompMessage};
use crate::session::stomp_session::StompSession;

// contains code for heart-beats, (keep-alive pings)

pub fn get_request_header(message: &StompMessage) -> Option<&Header> {
    for hdr in message.headers() {
        if hdr.name.eq("heart-beat") {
            return Some(hdr);
        }
    }
    None
}

/// get the header value to add to a CONNECTED reply
pub fn get_response_header(session: &Arc<RwLock<StompSession>>) -> Header {
    let session = session.read().unwrap();
    Header {
        name: String::from("heart-beat"),
        value: format!("{},{}", session.heart_beat_write, session.heart_beat_read)
    }
}

/// parse header and update the StompSession with expected heart-beat config
pub fn parse_header(hdr: &Header, session: &Arc<RwLock<StompSession>>) -> Result<(), &'static str> {

    // Rust is sooo ugly sometimes this parses "x,y"

    let comma_idx = (*hdr.value).find(',');
    match comma_idx {
        Some(comma_idx) => {
            let (cx, cy) = (*hdr.value).split_at(comma_idx);
            if cy.len() < 2 {
                return Err("ecg syntax");
            }
            // atoi(cx, cy)
            match (cx.parse::<u32>(), cy[1..].parse::<u32>()) {
                (Ok(cx), Ok(cy)) => {
                    let mut s = session.write().unwrap();

                    if cx == 0 {
                        s.heart_beat_read = 0;
                    } else if cx > CONFIG.heart_beat_read {
                        // error client can only guarantee beats every cx but we need beats every  CONFIG.heart_beat_read
                        debug!("ecg incompat");
                        return Err("ecg incompat");
                    } else {
                        s.heart_beat_read = CONFIG.heart_beat_read;
                    }

                    if cy == 0 || CONFIG.heart_beat_write_max == 0 {
                        s.heart_beat_write = 0;
                    } else if cy < CONFIG.heart_beat_write_min {
                        debug!("ecg incompat");
                        return Err("ecg incompat");
                    } else if cy > CONFIG.heart_beat_write_max {
                        s.heart_beat_write = CONFIG.heart_beat_write_max;
                    } else {
                        s.heart_beat_write = cy;
                    }

                    return Ok(());
                },
                _ => return Err("ecg syntax"),
            }
        },
        _ => {
            return Err("ecg syntax");
        },
    }
}



#[cfg(test)]
mod tests {

    use super::*;

    #[test]
    fn test_parse_header() {
        let session = Arc::new(RwLock::new(StompSession::new()));
        let hdr = Header::new("heart-beat", "60000,60000");
        match parse_header(&hdr, &session) {
            Ok(()) => {},
            Err(e) => panic!("parse failed '{}'", e),
        }

        let session = Arc::new(RwLock::new(StompSession::new()));
        let hdr = Header::new("heart-beat", "60000,");
        match parse_header(&hdr, &session) {
            Ok(()) => panic!("expected parse fail"),
            Err(_e) => {},
        }

        let session = Arc::new(RwLock::new(StompSession::new()));
        let hdr = Header::new("heart-beat", ",60000");
        match parse_header(&hdr, &session) {
            Ok(()) => panic!("expected parse fail"),
            Err(_e) => {},
        }

        let session = Arc::new(RwLock::new(StompSession::new()));
        let hdr = Header::new("heart-beat", "60000,600000");
        match parse_header(&hdr, &session) {
            Ok(()) => {
                let session = session.read().unwrap();
                assert_eq!(session.heart_beat_read, 120000); // N.B. heart_beat_read set to server config, client will send us more often than this, thats OK
                assert_eq!(session.heart_beat_write, CONFIG.heart_beat_write_max);
            },
            Err(_e) => {},
        }

        let session = Arc::new(RwLock::new(StompSession::new()));
        let hdr = Header::new("heart-beat", "60000,6000");
        match parse_header(&hdr, &session) {
            Ok(()) => {
                let session = session.read().unwrap();
                assert_eq!(session.heart_beat_read, 120000);
                assert_eq!(session.heart_beat_write, CONFIG.heart_beat_write_min);
            },
            Err(_e) => {},
        }

        let session = Arc::new(RwLock::new(StompSession::new()));
        let hdr = Header::new("heart-beat", "0,0");
        match parse_header(&hdr, &session) {
            Ok(()) => {
                let session = session.read().unwrap();
                assert_eq!(session.heart_beat_read, 0);
                assert_eq!(session.heart_beat_write, 0);
            },
            Err(_e) => {},
        }
    }

    #[test]
    fn test_parse_header_read_range() {
        let session = Arc::new(RwLock::new(StompSession::new()));
        let hdr = Header::new("heart-beat", "120001,60000");
        match parse_header(&hdr, &session) {
            Ok(()) => panic!("expect read out of range"),
            Err(_e) => {},
        }
    }
}