gatewayd: serve, the event loop, typing, catch-up and reconnecting

Implemented-By: OpenCode session (model recorded in docs/implementer-log.md)
2026-09-24 00:55:58 -07:00
parent 02d5e25046
commit ed361db718
8 changed files with 1389 additions and 0 deletions
@@ -0,0 +1,331 @@
+//! A fake Mattermost on 127.0.0.1, plain TCP: the four REST calls `gatewayd` makes, and the
+//! WebSocket, whose events the test sends and whose requests it reads. Do not edit.
+
+#![allow(dead_code)] // each test file uses a different part of this module
+
+use std::collections::HashMap;
+use std::io::{Read, Write};
+use std::net::{Shutdown, SocketAddr, TcpListener, TcpStream};
+use std::sync::{Arc, Mutex, mpsc};
+use std::time::{Duration, Instant};
+
+use gatewayd::ws::handshake::accept_for;
+use serde_json::{Value, json};
+
+pub const BOT: &str = "b0000000000000000000000000";
+pub const BOT_NAME: &str = "boxmaker-straylight";
+pub const KYLE: &str = "k0000000000000000000000000";
+pub const EVE: &str = "e0000000000000000000000000";
+/// The direct channel between the bot and Kyle, and between the bot and anyone else.
+pub const DM: &str = "d0000000000000000000000000";
+pub const EVE_DM: &str = "f0000000000000000000000000";
+
+#[derive(Default)]
+struct Inner {
+    /// Status for `users/me`: 200 unless a test sets another.
+    me_status: u16,
+    /// The body for `channels/<id>/posts?since=`, by channel.
+    since: HashMap<String, Value>,
+    /// Every post made: channel, root, message.
+    posts: Vec<(String, String, String)>,
+    /// Every REST call: method and path.
+    calls: Vec<(String, String)>,
+}
+
+pub struct FakeMm {
+    pub addr: SocketAddr,
+    inner: Arc<Mutex<Inner>>,
+    sockets: Mutex<mpsc::Receiver<WsPeer>>,
+}
+
+/// One WebSocket connection from `gatewayd`.
+pub struct WsPeer {
+    writer: TcpStream,
+    /// The text of every text frame `gatewayd` sends.
+    pub texts: mpsc::Receiver<String>,
+}
+
+/// A post as Mattermost sends it.
+pub fn post(
+    id: &str,
+    user: &str,
+    channel: &str,
+    root: &str,
+    message: &str,
+    create_at: i64,
+) -> Value {
+    json!({
+        "id": id, "create_at": create_at, "update_at": create_at, "delete_at": 0, "user_id": user,
+        "channel_id": channel, "root_id": root, "message": message, "type": "", "props": {}
+    })
+}
+
+pub fn id(prefix: char, n: u32) -> String {
+    format!("{prefix}{n:025}")
+}
+
+fn frame(opcode: u8, payload: &[u8]) -> Vec<u8> {
+    let mut out = vec![0x80 | opcode];
+    match payload.len() {
+        n if n < 126 => out.push(n as u8),
+        n => {
+            out.push(126);
+            out.extend_from_slice(&(n as u16).to_be_bytes());
+        }
+    }
+    out.extend_from_slice(payload);
+    out
+}
+
+impl WsPeer {
+    pub fn event(&mut self, value: &Value) {
+        let _ = self
+            .writer
+            .write_all(&frame(0x1, value.to_string().as_bytes()));
+    }
+
+    pub fn posted(&mut self, post: &Value, channel_type: &str) {
+        let data = json!({"post": post.to_string(), "channel_type": channel_type, "team_id": ""});
+        self.event(&json!({"event": "posted", "data": data, "broadcast": {}, "seq": 1}));
+    }
+
+    /// End the connection without a close frame.
+    pub fn drop_connection(self) {
+        let _ = self.writer.shutdown(Shutdown::Both);
+    }
+
+    /// The `user_typing` requests received within `wait`, as (channel, parent).
+    pub fn typing_within(&self, wait: Duration) -> Vec<(String, String)> {
+        let until = Instant::now() + wait;
+        let mut got = Vec::new();
+        while let Ok(text) = self
+            .texts
+            .recv_timeout(until.saturating_duration_since(Instant::now()))
+        {
+            let v: Value = serde_json::from_str(&text).unwrap();
+            if v["action"] == "user_typing" {
+                let data = &v["data"];
+                got.push((
+                    data["channel_id"].as_str().unwrap().to_string(),
+                    data["parent_id"].as_str().unwrap().to_string(),
+                ));
+            }
+        }
+        got
+    }
+}
+
+fn read_head(stream: &mut TcpStream) -> Option<String> {
+    let mut head = Vec::new();
+    let mut byte = [0u8; 1];
+    while !head.ends_with(b"\r\n\r\n") {
+        if stream.read(&mut byte).ok()? == 0 {
+            return None;
+        }
+        head.push(byte[0]);
+    }
+    String::from_utf8(head).ok()
+}
+
+/// Unmask the client's frames and send each text on `tx`, until the connection ends.
+fn read_frames(mut stream: TcpStream, tx: mpsc::Sender<String>) {
+    let mut exact = |n: usize| -> Option<Vec<u8>> {
+        let mut buf = vec![0u8; n];
+        stream.read_exact(&mut buf).ok().map(|()| buf)
+    };
+    loop {
+        let Some(head) = exact(2) else { return };
+        let len = match head[1] & 0x7F {
+            126 => u16::from_be_bytes(exact(2).unwrap().try_into().unwrap()) as usize,
+            127 => return,
+            n => n as usize,
+        };
+        let Some(mask) = exact(4) else { return };
+        let Some(raw) = exact(len) else { return };
+        let payload: Vec<u8> = raw
+            .iter()
+            .zip(mask.iter().cycle())
+            .map(|(b, m)| b ^ m)
+            .collect();
+        if head[0] & 0x0F == 0x1 {
+            let _ = tx.send(String::from_utf8(payload).unwrap());
+        }
+    }
+}
+
+impl FakeMm {
+    pub fn start() -> FakeMm {
+        let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+        let addr = listener.local_addr().unwrap();
+        let inner = Arc::new(Mutex::new(Inner {
+            me_status: 200,
+            ..Inner::default()
+        }));
+        let (ws_tx, ws_rx) = mpsc::channel();
+        let shared = Arc::clone(&inner);
+        std::thread::spawn(move || {
+            for stream in listener.incoming() {
+                let Ok(stream) = stream else { continue };
+                let (inner, ws_tx) = (Arc::clone(&shared), ws_tx.clone());
+                std::thread::spawn(move || connection(stream, &inner, &ws_tx));
+            }
+        });
+        FakeMm {
+            addr,
+            inner,
+            sockets: Mutex::new(ws_rx),
+        }
+    }
+
+    pub fn url(&self) -> String {
+        format!("http://127.0.0.1:{}", self.addr.port())
+    }
+
+    pub fn refuse_token(&self) {
+        self.inner.lock().unwrap().me_status = 401;
+    }
+
+    pub fn set_since(&self, channel: &str, posts: &[Value]) {
+        let order: Vec<Value> = posts.iter().map(|p| p["id"].clone()).collect();
+        let map: serde_json::Map<String, Value> = posts
+            .iter()
+            .map(|p| (p["id"].as_str().unwrap().to_string(), p.clone()))
+            .collect();
+        self.inner
+            .lock()
+            .unwrap()
+            .since
+            .insert(channel.to_string(), json!({"order": order, "posts": map}));
+    }
+
+    /// The next WebSocket `gatewayd` opens, after its hello.
+    pub fn next_ws(&self, wait: Duration) -> WsPeer {
+        self.sockets
+            .lock()
+            .unwrap()
+            .recv_timeout(wait)
+            .expect("no WebSocket connection")
+    }
+
+    pub fn posts(&self) -> Vec<(String, String, String)> {
+        self.inner.lock().unwrap().posts.clone()
+    }
+
+    /// Wait until at least `n` posts were made, for at most `wait`.
+    pub fn wait_posts(&self, n: usize, wait: Duration) -> Vec<(String, String, String)> {
+        let until = Instant::now() + wait;
+        while self.posts().len() < n && Instant::now() < until {
+            std::thread::sleep(Duration::from_millis(10));
+        }
+        self.posts()
+    }
+
+    pub fn calls(&self) -> Vec<(String, String)> {
+        self.inner.lock().unwrap().calls.clone()
+    }
+}
+
+fn connection(mut stream: TcpStream, inner: &Mutex<Inner>, ws_tx: &mpsc::Sender<WsPeer>) {
+    let Some(head) = read_head(&mut stream) else {
+        return;
+    };
+    let mut words = head.split_whitespace();
+    let (method, path) = (
+        words.next().unwrap_or("").to_string(),
+        words.next().unwrap_or("").to_string(),
+    );
+    if path == "/api/v4/websocket" {
+        let key = head
+            .lines()
+            .find_map(|l| l.strip_prefix("Sec-WebSocket-Key: "))
+            .unwrap_or("")
+            .trim()
+            .to_string();
+        let reply = format!(
+            "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: {}\r\n\r\n",
+            accept_for(&key)
+        );
+        let _ = stream.write_all(reply.as_bytes());
+        let _ = stream.write_all(&frame(
+            0x1,
+            br#"{"event":"hello","data":{},"broadcast":{},"seq":0}"#,
+        ));
+        let (tx, texts) = mpsc::channel();
+        let reader = stream.try_clone().unwrap();
+        std::thread::spawn(move || read_frames(reader, tx));
+        let _ = ws_tx.send(WsPeer {
+            writer: stream,
+            texts,
+        });
+        return;
+    }
+    let length = head
+        .lines()
+        .find_map(|l| {
+            l.to_ascii_lowercase()
+                .strip_prefix("content-length:")
+                .map(|v| v.trim().parse::<usize>().unwrap_or(0))
+        })
+        .unwrap_or(0);
+    let mut body = vec![0u8; length];
+    let _ = stream.read_exact(&mut body);
+    let (status, answer) = rest(inner, &method, &path, &body);
+    let text = answer.to_string();
+    let reply = format!(
+        "HTTP/1.1 {status} X\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{text}",
+        text.len()
+    );
+    let _ = stream.write_all(reply.as_bytes());
+}
+
+fn rest(inner: &Mutex<Inner>, method: &str, path: &str, body: &[u8]) -> (u16, Value) {
+    let mut inner = inner.lock().unwrap();
+    inner.calls.push((method.to_string(), path.to_string()));
+    match (method, path) {
+        ("GET", "/api/v4/users/me") if inner.me_status == 200 => {
+            (200, json!({"id": BOT, "username": BOT_NAME}))
+        }
+        ("GET", "/api/v4/users/me") => (
+            inner.me_status,
+            json!({"id": "api.context.session_expired.app_error"}),
+        ),
+        ("POST", "/api/v4/channels/direct") => {
+            let users: Vec<String> = serde_json::from_slice(body).unwrap();
+            let channel = if users.iter().any(|u| u == KYLE) {
+                DM
+            } else {
+                EVE_DM
+            };
+            (201, json!({"id": channel, "type": "D"}))
+        }
+        ("POST", "/api/v4/posts") => {
+            let p: Value = serde_json::from_slice(body).unwrap();
+            let n = u32::try_from(inner.posts.len()).unwrap();
+            let (channel, root, message) = (
+                p["channel_id"].as_str().unwrap(),
+                p["root_id"].as_str().unwrap(),
+                p["message"].as_str().unwrap(),
+            );
+            inner
+                .posts
+                .push((channel.to_string(), root.to_string(), message.to_string()));
+            (201, post(&id('x', n), BOT, channel, root, message, 1))
+        }
+        ("GET", p) if p.contains("/posts?since=") => {
+            let channel = p
+                .trim_start_matches("/api/v4/channels/")
+                .split('/')
+                .next()
+                .unwrap_or("");
+            (
+                200,
+                inner
+                    .since
+                    .get(channel)
+                    .cloned()
+                    .unwrap_or(json!({"order": [], "posts": {}})),
+            )
+        }
+        _ => (404, json!({"message": "not found"})),
+    }
+}