Upgrade rust-websocket, rust-openssl, and hyper

Upgrade `rust-websocket` to v0.20, maintaining use of its sync client.

This indirectly switches from `rust-openssl` v0.7 - which required
openssl-1.0 on all platforms - to `native-tls`, which allows for use of
schannel on Windows, Secure Transport on OSX, and openssl-1.1 on other
platforms.

Additionally, since hyper is no longer even a dependency of
rust-websocket, we can safely and easily upgrade to `hyper` v0.10 and
`multipart` v0.12.

This commit is fairly experimental as it has not been tested on a
long-running bot.

2 files changed, 51 insertions, 35 deletions

diff --git a/src/internal/macros.rs b/src/internal/macros.rs
index 1e09b2e..c2475d1 100644
--- a/src/internal/macros.rs
+++ b/src/internal/macros.rs
@@ -2,29 +2,45 @@
 
 macro_rules! request {
     ($route:expr, $method:ident($body:expr), $url:expr, $($rest:tt)*) => {{
-        let client = HyperClient::new();
+        let client = request_client!();
+
         request($route, || client
             .$method(&format!(api!($url), $($rest)*))
             .body(&$body))?
     }};
     ($route:expr, $method:ident($body:expr), $url:expr) => {{
-        let client = HyperClient::new();
+        let client = request_client!();
+
         request($route, || client
             .$method(api!($url))
             .body(&$body))?
     }};
     ($route:expr, $method:ident, $url:expr, $($rest:tt)*) => {{
-        let client = HyperClient::new();
+        let client = request_client!();
+
         request($route, || client
             .$method(&format!(api!($url), $($rest)*)))?
     }};
     ($route:expr, $method:ident, $url:expr) => {{
-        let client = HyperClient::new();
+        let client = request_client!();
+
         request($route, || client
             .$method(api!($url)))?
     }};
 }
 
+macro_rules! request_client {
+    () => {{
+        use hyper::net::HttpsConnector;
+        use hyper_native_tls::NativeTlsClient;
+
+        let tc = NativeTlsClient::new()?;
+        let connector = HttpsConnector::new(tc);
+
+        HyperClient::with_connector(connector)
+    }}
+}
+
 macro_rules! cdn {
     ($e:expr) => {
         concat!("https://cdn.discordapp.com", $e)
diff --git a/src/internal/ws_impl.rs b/src/internal/ws_impl.rs
index 5475a3e..0db40ee 100644
--- a/src/internal/ws_impl.rs
+++ b/src/internal/ws_impl.rs
@@ -1,10 +1,8 @@
 use flate2::read::ZlibDecoder;
 use serde_json;
-use websocket::client::{Receiver, Sender};
-use websocket::message::{Message as WsMessage, Type as WsType};
-use websocket::stream::WebSocketStream;
-use websocket::ws::receiver::Receiver as WsReceiver;
-use websocket::ws::sender::Sender as WsSender;
+use websocket::message::OwnedMessage;
+use websocket::sync::stream::{TcpStream, TlsStream};
+use websocket::sync::Client as WsClient;
 use ::gateway::GatewayError;
 use ::internal::prelude::*;
 
@@ -17,43 +15,45 @@ pub trait SenderExt {
     fn send_json(&mut self, value: &Value) -> Result<()>;
 }
 
-impl ReceiverExt for Receiver<WebSocketStream> {
+impl ReceiverExt for WsClient<TlsStream<TcpStream>> {
     fn recv_json<F, T>(&mut self, decode: F) -> Result<T> where F: FnOnce(Value) -> Result<T> {
-        let message: WsMessage = self.recv_message()?;
+        match self.recv_message()? {
+            OwnedMessage::Binary(bytes) => {
+                let value = serde_json::from_reader(ZlibDecoder::new(&bytes[..]))?;
 
-        if message.opcode == WsType::Close {
-            let r = String::from_utf8_lossy(&message.payload).into_owned();
-
-            Err(Error::Gateway(GatewayError::Closed(message.cd_status_code, r)))
-        } else if message.opcode == WsType::Binary || message.opcode == WsType::Text {
-            let json: Value = if message.opcode == WsType::Binary {
-                serde_json::from_reader(ZlibDecoder::new(&message.payload[..]))?
-            } else {
-                serde_json::from_reader(&message.payload[..])?
-            };
-
-            match decode(json) {
-                Ok(v) => Ok(v),
-                Err(why) => {
-                    let s = String::from_utf8_lossy(&message.payload);
+                decode(value).map_err(|why| {
+                    let s = String::from_utf8_lossy(&bytes);
 
                     warn!("(╯°□°）╯︵ ┻━┻ Error decoding: {}", s);
 
-                    Err(why)
-                }
-            }
-        } else {
-            let r = String::from_utf8_lossy(&message.payload).into_owned();
-
-            Err(Error::Gateway(GatewayError::Closed(None, r)))
+                    why
+                })
+            },
+            OwnedMessage::Close(data) => {
+                Err(Error::Gateway(GatewayError::Closed(data)))
+            },
+            OwnedMessage::Text(payload) => {
+                let value = serde_json::from_str(&payload)?;
+
+                decode(value).map_err(|why| {
+                    warn!("(╯°□°）╯︵ ┻━┻ Error decoding: {}", payload);
+
+                    why
+                })
+            },
+            OwnedMessage::Ping(x) | OwnedMessage::Pong(x) => {
+                warn!("Unexpectly got ping/pong: {:?}", x);
+
+                Err(Error::Gateway(GatewayError::Closed(None)))
+            },
         }
     }
 }
 
-impl SenderExt for Sender<WebSocketStream> {
+impl SenderExt for WsClient<TlsStream<TcpStream>> {
     fn send_json(&mut self, value: &Value) -> Result<()> {
         serde_json::to_string(value)
-            .map(WsMessage::text)
+            .map(OwnedMessage::Text)
             .map_err(Error::from)
             .and_then(|m| self.send_message(&m).map_err(Error::from))
     }