AnyBot/src/wire.rs

// (Shared with relay/.)
#![allow(dead_code)]
// One frame on the lasting connection between an AnyBot and the account server (a WebSocket):
// a small JSON header, then the body as raw bytes (no base64), in one binary message.
//
// Headers ("t" says which):
//   server → AnyBot  job   {id, method, path, query, user, role, z, z_ok}  a request for this AnyBot
//   AnyBot → server  reply {id, status, ctype, headers, z}                  its answer
//   AnyBot → server  call  {id, to, method, path, query, z}                 a request for another AnyBot of the account
//   server → AnyBot  ret   {id, status, ctype, z}                           that one's answer
//   AnyBot → server  hello {brain}                                          what this AnyBot shows
// "z": the body is deflate-compressed. "z_ok": the asker can read a compressed answer.

use serde_json::Value;

pub fn pack(head: &Value, body: &[u8]) -> Vec<u8> {
    let h = head.to_string();
    let mut out = Vec::with_capacity(4 + h.len() + body.len());
    out.extend_from_slice(&(h.len() as u32).to_be_bytes());
    out.extend_from_slice(h.as_bytes());
    out.extend_from_slice(body);
    out
}

pub fn unpack(b: &[u8]) -> Option<(Value, Vec<u8>)> {
    let n = u32::from_be_bytes(b.get(..4)?.try_into().ok()?) as usize;
    let head = serde_json::from_slice(b.get(4..4 + n)?).ok()?;
    Some((head, b[4 + n..].to_vec()))
}

/// How long a connection's loop waits to read before it sends what is queued: 2 ms while things
/// move (a live screen), 40 ms when quiet. A fixed 40 ms added up to 40 ms to every message on
/// each side of each hop.
pub struct Pace {
    moved: std::time::Instant,
    busy: Option<bool>,
}

impl Pace {
    pub fn new() -> Pace {
        Pace { moved: std::time::Instant::now() - std::time::Duration::from_secs(60), busy: None }
    }
    /// Something was read or sent.
    pub fn moved(&mut self) {
        self.moved = std::time::Instant::now();
    }
    /// Set the socket's read wait for now (only when it changes).
    pub fn tune(&mut self, c: &std::net::TcpStream) {
        let busy = self.moved.elapsed() < std::time::Duration::from_secs(2);
        if self.busy != Some(busy) {
            self.busy = Some(busy);
            let _ = c.set_read_timeout(Some(std::time::Duration::from_millis(if busy { 2 } else { 40 })));
        }
    }
}

#[cfg(test)]
mod tests {
    #[test]
    fn frames_round_trip() {
        let head = serde_json::json!({"t": "job", "id": "a"});
        let f = super::pack(&head, b"\x00\x01body");
        let (h, b) = super::unpack(&f).unwrap();
        assert_eq!(h, head);
        assert_eq!(b, b"\x00\x01body");
        assert!(super::unpack(&f[..3]).is_none());
    }
}