Matched sync server API with async, small fixes.

Author: illegalprime

src/result.rs

@@ -7,6 +7,7 @@ use std::convert::From;
 use std::fmt;
 use hyper::Error as HttpError;
 use url::ParseError;
+use server::upgrade::HyperIntoWsError;
 
 #[cfg(any(feature="sync-ssl", feature="async-ssl"))]
 use native_tls::Error as TlsError;
@@ -16,6 +17,12 @@ use native_tls::HandshakeError as TlsHandshakeError;
 /// The type used for WebSocket results
 pub type WebSocketResult<T> = Result<T, WebSocketError>;
 
+pub mod async {
+	use futures::Future;
+	use super::WebSocketError;
+	pub type WebSocketFuture<I> = Box<Future<Item = I, Error = WebSocketError>>;
+}
+
 /// Represents a WebSocket error
 #[derive(Debug)]
 pub enum WebSocketError {
@@ -154,6 +161,25 @@ impl From<WSUrlErrorKind> for WebSocketError {
 	}
 }
 
+impl From<HyperIntoWsError> for WebSocketError {
+	fn from(err: HyperIntoWsError) -> WebSocketError {
+		use self::HyperIntoWsError::*;
+		use WebSocketError::*;
+		match err {
+			Io(io) => IoError(io),
+			Parsing(err) => HttpError(err),
+			MethodNotGet => ProtocolError("Request method must be GET"),
+			UnsupportedHttpVersion => ProtocolError("Unsupported request HTTP version"),
+			UnsupportedWebsocketVersion => ProtocolError("Unsupported WebSocket version"),
+			NoSecWsKeyHeader => ProtocolError("Missing Sec-WebSocket-Key header"),
+			NoWsUpgradeHeader => ProtocolError("Invalid Upgrade WebSocket header"),
+			NoUpgradeHeader => ProtocolError("Missing Upgrade WebSocket header"),
+			NoWsConnectionHeader => ProtocolError("Invalid Connection WebSocket header"),
+			NoConnectionHeader => ProtocolError("Missing Connection WebSocket header"),
+		}
+	}
+}
+
 /// Represents a WebSocket URL error
 #[derive(Debug)]
 pub enum WSUrlErrorKind {

src/server/async.rs

@@ -1,5 +1,5 @@
 use std::io;
-use std::net::SocketAddr;
+use std::net::ToSocketAddrs;
 use server::{WsServer, NoTlsAcceptor};
 use tokio_core::net::{TcpListener, TcpStream};
 use futures::{Stream, Future};
@@ -23,9 +23,11 @@ pub enum AcceptError<E> {
 }
 
 impl WsServer<NoTlsAcceptor, TcpListener> {
-	pub fn bind(addr: &SocketAddr, handle: &Handle) -> io::Result<Self> {
+	pub fn bind<A: ToSocketAddrs>(addr: A, handle: &Handle) -> io::Result<Self> {
+		let tcp = ::std::net::TcpListener::bind(addr)?;
+		let address = tcp.local_addr()?;
 		Ok(Server {
-		       listener: TcpListener::bind(addr, handle)?,
+		       listener: TcpListener::from_listener(tcp, &address, handle)?,
 		       ssl_acceptor: NoTlsAcceptor,
 		   })
 	}
@@ -58,13 +60,15 @@ impl WsServer<NoTlsAcceptor, TcpListener> {
 
 #[cfg(any(feature="async-ssl"))]
 impl WsServer<TlsAcceptor, TcpListener> {
-	pub fn bind_secure(
-		addr: &SocketAddr,
+	pub fn bind_secure<A: ToSocketAddrs>(
+		addr: A,
 		acceptor: TlsAcceptor,
 		handle: &Handle,
 	) -> io::Result<Self> {
+		let tcp = ::std::net::TcpListener::bind(addr)?;
+		let address = tcp.local_addr()?;
 		Ok(Server {
-		       listener: TcpListener::bind(addr, handle)?,
+		       listener: TcpListener::from_listener(tcp, &address, handle)?,
 		       ssl_acceptor: acceptor,
 		   })
 	}

src/server/upgrade/async.rs

@@ -44,7 +44,7 @@ impl<S> WsUpgrade<S, BytesMut>
 		                             headers: headers.clone(),
 		                         })
 		                   .map(move |s| {
-			                        let codec = MessageCodec::default(Context::Client);
+			                        let codec = MessageCodec::default(Context::Server);
 			                        let client = Framed::from_parts(s.into_parts(), codec);
 			                        (client, headers)
 			                       })

src/server/upgrade/mod.rs

@@ -86,7 +86,7 @@ impl<S, B> WsUpgrade<S, B>
 		::std::mem::drop(self);
 	}
 
-	/// Aelist of protocols requested from the client.
+	/// A list of protocols requested from the client.
 	pub fn protocols(&self) -> &[String] {
 		self.request
 		    .headers