add: initial with some message handling

Author: Pctg-x8

.editorconfig

@@ -0,0 +1,6 @@
+[*.rs]
+indent_style = space
+indent_size = 4
+end_of_line = lf
+trim_trailing_whitespace = true
+insert_final_newline = true

.gitignore

@@ -0,0 +1,3 @@
+/target
+Cargo.lock
+.vscode

Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "slack-socket-mode-client"
+version = "0.1.0"
+authors = ["S.Percentage <Syn.Tri.Naga@gmail.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[features]
+default = []
+runtime-async-std = ["async-std", "surf"]
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+tungstenite = "0.12"
+async-tungstenite = "0.12"
+url = "2.2"
+futures-util = "0.3"
+log = "0.4"
+async-tls = { version = "0.11", default-features = false, features = ["client"] }
+
+async-std = { version = "1.9", optional = true }
+surf = { version = "2.1", optional = true }
+
+[dev-dependencies]
+env_logger = "0.5"
+async-std = { version = "1.9", features = ["attributes"] }

examples/simple.rs

@@ -0,0 +1,21 @@
+#[async_std::main]
+async fn main() {
+    env_logger::init();
+
+    let dr = slack_socket_mode_client::run(env!("SLACK_APP_TOKEN"), &mut EventHandler)
+        .await
+        .expect("Failed to run socket mode client");
+    println!("disconnected: {:?}", dr);
+}
+
+pub struct EventHandler;
+impl slack_socket_mode_client::EventHandler for EventHandler {
+    fn on_hello(
+        &mut self,
+        _: slack_socket_mode_client::protocol::ConnectionInfo,
+        _: u32,
+        d: slack_socket_mode_client::protocol::DebugInfo,
+    ) {
+        println!("Hello! approx_connection_time: {}s", d.approximate_connection_time.unwrap_or(0));
+    }
+}

rustfmt.toml

@@ -0,0 +1 @@
+max_width = 120

src/lib.rs

@@ -0,0 +1,131 @@
+//! Slack Socket Mode API Client Library
+
+use futures_util::{SinkExt, StreamExt};
+use url::Url;
+
+pub mod protocol;
+
+#[allow(unused_variables)]
+pub trait EventHandler {
+    fn on_hello(
+        &mut self,
+        connection_info: protocol::ConnectionInfo,
+        num_connections: u32,
+        debug_info: protocol::DebugInfo,
+    ) {
+    }
+
+    fn on_events_api(&mut self) {}
+}
+
+#[derive(Debug, Clone)]
+pub enum DisconnectReason {
+    RefreshRequested,
+    Other(String),
+    Unknown,
+}
+
+#[derive(Debug)]
+pub enum RunError {
+    HttpClientError(HttpClientError),
+    OpenConnectionApiError(Option<String>),
+    UrlParseError(url::ParseError),
+    #[cfg(feature = "runtime-async-std")]
+    TcpStreamConnectionError(async_std::io::Error),
+    TlsConnectionError(std::io::Error),
+    WebSocketError(tungstenite::Error),
+}
+impl From<HttpClientError> for RunError {
+    fn from(e: HttpClientError) -> Self {
+        Self::HttpClientError(e)
+    }
+}
+impl From<url::ParseError> for RunError {
+    fn from(e: url::ParseError) -> Self {
+        Self::UrlParseError(e)
+    }
+}
+impl From<tungstenite::Error> for RunError {
+    fn from(e: tungstenite::Error) -> Self {
+        Self::WebSocketError(e)
+    }
+}
+
+pub async fn run<H: EventHandler + ?Sized>(token: &str, handler: &mut H) -> Result<DisconnectReason, RunError> {
+    let ws_url = open_connection(token)
+        .await?
+        .map_err(RunError::OpenConnectionApiError)?;
+    let ws_parsed = Url::parse(&ws_url)?;
+    let ws_domain = ws_parsed.domain().expect("WebSocket URL doesn't have domain");
+
+    #[cfg(feature = "runtime-async-std")]
+    let tcp_stream = async_std::net::TcpStream::connect((ws_domain, 443))
+        .await
+        .map_err(RunError::TcpStreamConnectionError)?;
+    let enc_stream = async_tls::TlsConnector::default()
+        .connect(ws_domain, tcp_stream)
+        .await
+        .map_err(RunError::TlsConnectionError)?;
+    let (mut ws, _) = async_tungstenite::client_async(&ws_url, enc_stream).await?;
+
+    while let Some(msg) = ws.next().await {
+        match msg? {
+            tungstenite::Message::Text(t) => match serde_json::from_str(&t) {
+                Ok(protocol::Message::Hello {
+                    num_connections,
+                    connection_info,
+                    debug_info,
+                }) => {
+                    handler.on_hello(connection_info, num_connections, debug_info);
+                }
+                Ok(protocol::Message::Disconnect { reason, .. }) => {
+                    return match reason {
+                        "refresh_requested" => Ok(DisconnectReason::RefreshRequested),
+                        s => Ok(DisconnectReason::Other(String::from(s))),
+                    }
+                }
+                Err(e) => {
+                    log::error!("Failed to parse incoming message: {}: {:?}", t, e);
+                }
+            },
+            tungstenite::Message::Ping(p) => {
+                ws.send(tungstenite::Message::Pong(p)).await?;
+            }
+            tungstenite::Message::Close(_) => {
+                break;
+            }
+            m => {
+                log::warn!("Unsupported WebSocket Message: {:?}", m);
+            }
+        }
+    }
+
+    Ok(DisconnectReason::Unknown)
+}
+
+#[cfg(feature = "runtime-async-std")]
+type HttpClientError = surf::Error;
+
+async fn open_connection(token: &str) -> Result<Result<String, Option<String>>, HttpClientError> {
+    #[derive(serde::Deserialize)]
+    pub struct ApiResponse {
+        ok: bool,
+        url: Option<String>,
+        error: Option<String>,
+    }
+    let mut tok_bearer = String::with_capacity(token.len() + 7);
+    tok_bearer.push_str("Bearer ");
+    tok_bearer.push_str(token);
+
+    #[cfg(feature = "runtime-async-std")]
+    let r: ApiResponse = surf::post("https://slack.com/api/apps.connections.open")
+        .header(surf::http::headers::AUTHORIZATION, tok_bearer)
+        .recv_json()
+        .await?;
+
+    Ok(if r.ok {
+        Ok(r.url.expect("no url returned from api?"))
+    } else {
+        Err(r.error)
+    })
+}

src/protocol.rs

@@ -0,0 +1,33 @@
+//! JSON Types
+
+use serde::Deserialize;
+
+#[derive(Deserialize, Debug)]
+#[serde(rename_all = "snake_case", tag = "type")]
+pub enum Message<'s> {
+    Hello {
+        num_connections: u32,
+        #[serde(borrow = "'s")]
+        connection_info: ConnectionInfo<'s>,
+        #[serde(borrow = "'s")]
+        debug_info: DebugInfo<'s>,
+    },
+    Disconnect {
+        reason: &'s str,
+        #[serde(borrow = "'s")]
+        debug_info: DebugInfo<'s>,
+    },
+}
+
+#[derive(Deserialize, Debug)]
+pub struct ConnectionInfo<'s> {
+    pub app_id: &'s str,
+}
+
+#[derive(Deserialize, Debug)]
+pub struct DebugInfo<'s> {
+    pub host: &'s str,
+    pub started: Option<&'s str>,
+    pub build_number: Option<u32>,
+    pub approximate_connection_time: Option<u64>,
+}