@lovrozagar/honey 0.7.3 → 1.0.0-rc.1

package/src/client-rust/ws.rs

@@ -1,167 +0,0 @@
-/* Code generated by honey. DO NOT EDIT. */
-
-use crate::errors::Error;
-use serde::Serialize;
-use std::collections::HashMap;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::Mutex;
-use tokio_tungstenite::tungstenite::Message;
-use tokio_tungstenite::WebSocketStream;
-
-/// WS_STATUS_NORMAL_CLOSURE is the normal WebSocket close code (1000).
-pub const WS_STATUS_NORMAL_CLOSURE: u16 = 1000;
-
-/// WS_STATUS_GOING_AWAY is the going-away WebSocket close code (1001).
-pub const WS_STATUS_GOING_AWAY: u16 = 1001;
-
-/// WS_STATUS_PROTOCOL_ERROR is the protocol error WebSocket close code (1002).
-pub const WS_STATUS_PROTOCOL_ERROR: u16 = 1002;
-
-type WsStream = WebSocketStream<tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>>;
-
-type WsHandler = Box<dyn Fn(&[u8]) + Send + Sync>;
-type SharedHandler = std::sync::Arc<dyn Fn(&[u8]) + Send + Sync>;
-type HandlerMap = Mutex<HashMap<String, Vec<SharedHandler>>>;
-
-/// TypedWebSocket wraps a tokio-tungstenite connection with an event fanout
-/// system that mirrors the TS client's .on() escape hatch: "message" handlers
-/// get each payload, "close" handlers the close reason, "error" handlers the
-/// error text.
-pub struct TypedWebSocket {
-    conn: WsStream,
-    handlers: HandlerMap,
-    closed: AtomicBool,
-}
-
-impl TypedWebSocket {
-    /// new constructs a TypedWebSocket from an already-dialled stream.
-    pub fn new(conn: WsStream) -> Self {
-        TypedWebSocket {
-            conn,
-            handlers: Mutex::new(HashMap::new()),
-            closed: AtomicBool::new(false),
-        }
-    }
-
-    /// send_text writes a text frame as-is.
-    pub async fn send_text(&mut self, text: &str) -> Result<(), Error> {
-        use futures_util::SinkExt;
-        self.conn
-            .send(Message::Text(text.to_string()))
-            .await
-            .map_err(|e| Error::Other(e.to_string()))
-    }
-
-    /// send_binary writes a binary frame as-is.
-    pub async fn send_binary(&mut self, data: &[u8]) -> Result<(), Error> {
-        use futures_util::SinkExt;
-        self.conn
-            .send(Message::Binary(data.to_vec()))
-            .await
-            .map_err(|e| Error::Other(e.to_string()))
-    }
-
-    /// send serialises data to JSON and writes it to the WebSocket connection.
-    /// Accepts any serde_json::Value or JSON-serializable payload pre-encoded as Value.
-    pub async fn send(&mut self, data: &serde_json::Value) -> Result<(), Error> {
-        use futures_util::SinkExt;
-        let encoded = serde_json::to_vec(data).map_err(Error::Json)?;
-        self.conn
-            .send(Message::Text(String::from_utf8_lossy(&encoded).into_owned()))
-            .await
-            .map_err(|e| Error::Other(e.to_string()))
-    }
-
-    /// send_typed serialises any Serialize value to JSON and writes it to the WebSocket connection.
-    pub async fn send_typed<T: Serialize + ?Sized>(&mut self, data: &T) -> Result<(), Error> {
-        use futures_util::SinkExt;
-        let encoded = serde_json::to_vec(data).map_err(Error::Json)?;
-        self.conn
-            .send(Message::Text(String::from_utf8_lossy(&encoded).into_owned()))
-            .await
-            .map_err(|e| Error::Other(e.to_string()))
-    }
-
-    /// close sends a WebSocket close frame with the given status code and reason
-    /// (truncated to the 123 bytes a close frame can carry).
-    pub async fn close(&mut self, code: u16, reason: &str) -> Result<(), Error> {
-        use futures_util::SinkExt;
-        use tokio_tungstenite::tungstenite::protocol::frame::coding::CloseCode;
-        use tokio_tungstenite::tungstenite::protocol::CloseFrame;
-        let mut end = reason.len().min(123);
-        while !reason.is_char_boundary(end) {
-            end -= 1;
-        }
-        let frame = CloseFrame {
-            code: CloseCode::from(code),
-            reason: reason[..end].to_string().into(),
-        };
-        self.fire_close(&reason[..end]);
-        self.conn
-            .send(Message::Close(Some(frame)))
-            .await
-            .map_err(|e| Error::Other(e.to_string()))
-    }
-
-    /// read reads the next message from the connection.
-    pub async fn read(&mut self) -> Result<Vec<u8>, Error> {
-        use futures_util::StreamExt;
-        loop {
-            match self.conn.next().await {
-                None => {
-                    self.fire_close("");
-                    return Err(Error::Closed { code: 1006, reason: String::new() });
-                }
-                Some(Err(e)) => {
-                    let msg = e.to_string();
-                    self.fanout("error", msg.as_bytes());
-                    return Err(Error::Other(msg));
-                }
-                Some(Ok(msg)) => {
-                    let data = match msg {
-                        Message::Text(t) => t.into_bytes(),
-                        Message::Binary(b) => b,
-                        Message::Close(frame) => {
-                            let (code, reason) = match frame {
-                                Some(f) => (u16::from(f.code), f.reason.into_owned()),
-                                None => (1005, String::new()),
-                            };
-                            self.fire_close(&reason);
-                            return Err(Error::Closed { code, reason });
-                        }
-                        _ => continue,
-                    };
-                    self.fanout("message", &data);
-                    return Ok(data);
-                }
-            }
-        }
-    }
-
-    /// on registers an event handler for a named event.
-    /// Supported events: "message", "close", "error", "open".
-    pub fn on(&mut self, event: &str, handler: WsHandler) {
-        let mut handlers = self.handlers.lock().unwrap_or_else(|p| p.into_inner());
-        handlers
-            .entry(event.to_string())
-            .or_default()
-            .push(std::sync::Arc::from(handler));
-    }
-
-    fn fire_close(&self, reason: &str) {
-        if !self.closed.swap(true, Ordering::AcqRel) {
-            self.fanout("close", reason.as_bytes());
-        }
-    }
-
-    /// fanout calls handlers outside the lock, so a panicking handler cannot poison it.
-    fn fanout(&self, event: &str, data: &[u8]) {
-        let hs: Vec<SharedHandler> = {
-            let handlers = self.handlers.lock().unwrap_or_else(|p| p.into_inner());
-            handlers.get(event).cloned().unwrap_or_default()
-        };
-        for h in hs {
-            h(data);
-        }
-    }
-}