Updated doc examples and tests, added to travis.

Author: illegalprime

examples/async-autobahn-server.rs

@@ -52,4 +52,3 @@ fn main() {
 
 	core.run(f).unwrap();
 }
-

scripts/autobahn-client.sh

@@ -15,18 +15,25 @@ wstest -m fuzzingserver -s 'autobahn/fuzzingserver.json' & \
     FUZZINGSERVER_PID=$!
 sleep 10
 
+function test_diff() {
+    DIFF=$(diff \
+        <(jq -S 'del(."rust-websocket" | .. | .duration?)' 'autobahn/client-results.json') \
+        <(jq -S 'del(."rust-websocket" | .. | .duration?)' 'autobahn/client/index.json') )
+
+    if [[ $DIFF ]]; then
+        echo 'Difference in results, either this is a regression or' \
+             'one should update autobahn/client-results.json with the new results.' \
+             'The results are:'
+        echo $DIFF
+        exit 64
+    fi
+}
+
 cargo build --example autobahn-client
 cargo run --example autobahn-client
+test_diff
 
-DIFF=$(diff \
-    <(jq -S 'del(."rust-websocket" | .. | .duration?)' 'autobahn/client-results.json') \
-    <(jq -S 'del(."rust-websocket" | .. | .duration?)' 'autobahn/client/index.json') )
-
-if [[ $DIFF ]]; then
-    echo Difference in results, either this is a regression or \
-         one should update autobahn/client-results.json with the new results. \
-         The results are:
-    echo $DIFF
-    exit 64
-fi
+cargo build --example async-autobahn-client
+cargo run --example async-autobahn-client
+test_diff
 

scripts/autobahn-server.sh

@@ -12,23 +12,35 @@ function cleanup() {
 }
 trap cleanup TERM EXIT
 
+function test_diff() {
+    DIFF=$(diff \
+        <(jq -S 'del(."rust-websocket" | .. | .duration?)' 'autobahn/server-results.json') \
+        <(jq -S 'del(."rust-websocket" | .. | .duration?)' 'autobahn/server/index.json') )
+
+    if [[ $DIFF ]]; then
+        echo Difference in results, either this is a regression or \
+             one should update autobahn/server-results.json with the new results. \
+             The results are:
+        echo $DIFF
+        exit 64
+    fi
+}
+
+# Test synchronous version
 cargo build --example autobahn-server
-./target/debug/examples/autobahn-server & \
-    WSSERVER_PID=$!
+./target/debug/examples/autobahn-server & WSSERVER_PID=$!
 echo "Server PID: ${WSSERVER_PID}"
 sleep 10
-
 wstest -m fuzzingclient -s 'autobahn/fuzzingclient.json'
+kill -9 ${WSSERVER_PID}
+test_diff
 
-DIFF=$(diff \
-    <(jq -S 'del(."rust-websocket" | .. | .duration?)' 'autobahn/server-results.json') \
-    <(jq -S 'del(."rust-websocket" | .. | .duration?)' 'autobahn/server/index.json') )
-
-if [[ $DIFF ]]; then
-    echo Difference in results, either this is a regression or \
-         one should update autobahn/server-results.json with the new results. \
-         The results are:
-    echo $DIFF
-    exit 64
-fi
+# Test asynchronous version
+cargo build --example async-autobahn-server
+./target/debug/examples/async-autobahn-server & WSSERVER_PID=$!
+echo "Server PID: ${WSSERVER_PID}"
+sleep 10
+wstest -m fuzzingclient -s 'autobahn/fuzzingclient.json'
+kill -9 ${WSSERVER_PID}
+test_diff
 

src/client/builder.rs

@@ -443,7 +443,7 @@ impl<'u> ClientBuilder<'u> {
 	///
 	/// ```rust
 	/// # use websocket::ClientBuilder;
-	/// use websocket::stream::ReadWritePair;
+	/// use websocket::sync::stream::ReadWritePair;
 	/// use std::io::Cursor;
 	///
 	/// let accept = b"HTTP/1.1 101 Switching Protocols\r

src/client/sync.rs

@@ -165,11 +165,9 @@ impl<S> Client<S>
 	///
 	/// client.send_message(&Message::text("Hello world!")).unwrap();
 	///
-	/// let message: Message = client.recv_message().unwrap();
+	/// let response = client.recv_message().unwrap();
 	/// ```
-	pub fn recv_message<I>(&mut self) -> WebSocketResult<OwnedMessage>
-		where I: Iterator<Item = DataFrame>
-	{
+	pub fn recv_message(&mut self) -> WebSocketResult<OwnedMessage> {
 		self.receiver.recv_message(&mut self.stream)
 	}
 
@@ -260,7 +258,6 @@ impl<S> Client<S>
 	/// ```rust,no_run
 	/// # use websocket::ClientBuilder;
 	/// use std::io::Cursor;
-	/// use websocket::Message;
 	/// use websocket::ws::receiver::Receiver as ReceiverTrait;
 	/// use websocket::receiver::Receiver;
 	///
@@ -276,7 +273,7 @@ impl<S> Client<S>
 	/// /* transform buf somehow */
 	///
 	/// let mut buf_reader = Cursor::new(&mut buf);
-	/// let message: Message = receiver.recv_message(&mut buf_reader).unwrap();
+	/// let message = receiver.recv_message(&mut buf_reader).unwrap();
 	/// ```
 	pub fn reader_mut(&mut self) -> &mut Read {
 		&mut self.stream
@@ -299,14 +296,13 @@ impl<S> Client<S>
 	///```no_run
 	///# extern crate websocket;
 	///# fn main() {
-	///use websocket::{ClientBuilder, Message};
+	///use websocket::ClientBuilder;
 	///
 	///let mut client = ClientBuilder::new("ws://127.0.0.1:1234").unwrap()
 	///                     .connect(None).unwrap();
 	///
 	///for message in client.incoming_messages() {
-	///    let message: Message = message.unwrap();
-	///    println!("Recv: {:?}", message);
+	///    println!("Recv: {:?}", message.unwrap());
 	///}
 	///# }
 	///```
@@ -318,17 +314,16 @@ impl<S> Client<S>
 	///```no_run
 	///# extern crate websocket;
 	///# fn main() {
-	///use websocket::{ClientBuilder, Message};
+	///use websocket::ClientBuilder;
 	///
 	///let mut client = ClientBuilder::new("ws://127.0.0.1:1234").unwrap()
 	///                     .connect_insecure().unwrap();
 	///
 	///let (mut receiver, mut sender) = client.split().unwrap();
 	///
 	///for message in receiver.incoming_messages() {
-	///    let message: Message = message.unwrap();
 	///    // Echo the message back
-	///    sender.send_message(&message).unwrap();
+	///    sender.send_message(&message.unwrap()).unwrap();
 	///}
 	///# }
 	///```
@@ -357,8 +352,7 @@ impl<S> Client<S>
 	///
 	///thread::spawn(move || {
 	///    for message in receiver.incoming_messages() {
-	///        let message: Message = message.unwrap();
-	///        println!("Recv: {:?}", message);
+	///        println!("Recv: {:?}", message.unwrap());
 	///    }
 	///});
 	///

src/result.rs

@@ -17,6 +17,7 @@ use native_tls::HandshakeError as TlsHandshakeError;
 /// The type used for WebSocket results
 pub type WebSocketResult<T> = Result<T, WebSocketError>;
 
+#[cfg(feature="async")]
 pub mod async {
 	use futures::Future;
 	use super::WebSocketError;

src/server/sync.rs

@@ -4,7 +4,6 @@ use std::io;
 use std::convert::Into;
 #[cfg(feature="sync-ssl")]
 use native_tls::{TlsStream, TlsAcceptor};
-use stream::Stream;
 use server::{WsServer, OptionalTlsAcceptor, NoTlsAcceptor, InvalidConnection};
 use server::upgrade::sync::{Upgrade, IntoWs, Buffer};
 pub use server::upgrade::{Request, HyperIntoWsError};
@@ -33,7 +32,8 @@ pub type AcceptResult<S> = Result<Upgrade<S>, InvalidConnection<S, Buffer>>;
 ///extern crate websocket;
 ///# fn main() {
 ///use std::thread;
-///use websocket::{Server, Message};
+///use websocket::Message;
+///use websocket::sync::Server;
 ///
 ///let server = Server::bind("127.0.0.1:1234").unwrap();
 ///
@@ -54,30 +54,24 @@ pub type AcceptResult<S> = Result<Upgrade<S>, InvalidConnection<S, Buffer>>;
 ///# Secure Servers
 /// ```no_run
 ///extern crate websocket;
-///extern crate openssl;
+///extern crate native_tls;
 ///# fn main() {
 ///use std::thread;
 ///use std::io::Read;
 ///use std::fs::File;
-///use websocket::{Server, Message};
-///use openssl::pkcs12::Pkcs12;
-///use openssl::ssl::{SslMethod, SslAcceptorBuilder, SslStream};
+///use websocket::Message;
+///use websocket::sync::Server;
+///use native_tls::{Pkcs12, TlsAcceptor};
 ///
 ///// In this example we retrieve our keypair and certificate chain from a PKCS #12 archive,
 ///// but but they can also be retrieved from, for example, individual PEM- or DER-formatted
 ///// files. See the documentation for the `PKey` and `X509` types for more details.
 ///let mut file = File::open("identity.pfx").unwrap();
 ///let mut pkcs12 = vec![];
 ///file.read_to_end(&mut pkcs12).unwrap();
-///let pkcs12 = Pkcs12::from_der(&pkcs12).unwrap();
-///let identity = pkcs12.parse("password123").unwrap();
+///let pkcs12 = Pkcs12::from_der(&pkcs12, "hacktheplanet").unwrap();
 ///
-///let acceptor = SslAcceptorBuilder::mozilla_intermediate(SslMethod::tls(),
-///                                                        &identity.pkey,
-///                                                        &identity.cert,
-///                                                        &identity.chain)
-///                   .unwrap()
-///                   .build();
+///let acceptor = TlsAcceptor::builder(pkcs12).unwrap().build().unwrap();
 ///
 ///let server = Server::bind_secure("127.0.0.1:1234", acceptor).unwrap();
 ///
@@ -116,14 +110,16 @@ impl<S> WsServer<S, TcpListener>
 	}
 
 	/// Changes whether the Server is in nonblocking mode.
+	/// NOTE: It is strongly encouraged to use the `websocket::async` module instead
+	/// of this. It provides high level APIs for creating asynchronous servers.
 	///
-	/// If it is in nonblocking mode, accept() will return an error instead of blocking when there
-	/// are no incoming connections.
+	/// If it is in nonblocking mode, accept() will return an error instead of
+	/// blocking when there are no incoming connections.
 	///
 	///# Examples
 	///```no_run
 	/// # extern crate websocket;
-	/// # use websocket::Server;
+	/// # use websocket::sync::Server;
 	/// # fn main() {
 	/// // Suppose we have to work in a single thread, but want to
 	/// // accomplish two unrelated things:

src/server/upgrade/mod.rs

@@ -1,7 +1,6 @@
 //! Allows you to take an existing request or stream of data and convert it into a
 //! WebSocket client.
 use std::error::Error;
-use std::net::TcpStream;
 use std::io;
 use std::fmt::{self, Formatter, Display};
 use stream::Stream;

src/server/upgrade/sync.rs

@@ -119,8 +119,8 @@ impl<S, B> WsUpgrade<S, B>
 /// ```rust,no_run
 /// use std::net::TcpListener;
 /// use std::net::TcpStream;
-/// use websocket::server::upgrade::IntoWs;
-/// use websocket::Client;
+/// use websocket::sync::server::upgrade::IntoWs;
+/// use websocket::sync::Client;
 ///
 /// let listener = TcpListener::bind("127.0.0.1:80").unwrap();
 ///
@@ -221,8 +221,8 @@ impl<S> IntoWs for RequestStreamPair<S>
 /// # fn main() {
 /// use hyper::server::{Server, Request, Response};
 /// use websocket::Message;
-/// use websocket::server::upgrade::IntoWs;
-/// use websocket::server::upgrade::from_hyper::HyperRequest;
+/// use websocket::sync::server::upgrade::IntoWs;
+/// use websocket::sync::server::upgrade::HyperRequest;
 ///
 /// Server::http("0.0.0.0:80").unwrap().handle(move |req: Request, res: Response| {
 ///     match HyperRequest(req).into_ws() {

src/stream.rs

@@ -1,6 +1,6 @@
 //! Provides the default stream type for WebSocket connections.
 
-use std::io::{self, Read, Write};
+use std::io::{Read, Write};
 
 /// Represents a stream that can be read from, and written to.
 /// This is an abstraction around readable and writable things to be able