Added async server example and updated examples.

Author: illegalprime

examples/async-server.rs

@@ -0,0 +1,62 @@
+extern crate websocket;
+extern crate futures;
+extern crate tokio_core;
+
+use websocket::message::{Message, OwnedMessage};
+use websocket::server::InvalidConnection;
+use websocket::async::Server;
+use websocket::async::client::Client;
+use websocket::async::WebSocketFuture;
+
+use tokio_core::reactor::Core;
+use tokio_core::net::TcpStream;
+use futures::{Future, Sink, Stream};
+
+fn main() {
+	let mut core = Core::new().unwrap();
+	let handle = core.handle();
+	// bind to the server
+	let server = Server::bind("127.0.0.1:2794", &handle).unwrap();
+
+	// time to build the server's future
+	// this will be a struct containing everything the server is going to do
+
+	// a stream of incoming connections
+	let f = server.incoming()
+        // we don't wanna save the stream if it drops
+        .map_err(|InvalidConnection { error, .. }| error.into())
+        // negotiate with the client
+        .and_then(|upgrade| {
+            // check if it has the protocol we want
+            let uses_proto = upgrade.protocols().iter().any(|s| s == "rust-websocket");
+
+            let f: WebSocketFuture<Option<Client<TcpStream>>> = if uses_proto {
+                // accept the request to be a ws connection if it does
+                Box::new(upgrade.use_protocol("rust-websocket").accept().map(|(s, _)| Some(s)))
+            } else {
+                // reject it if it doesn't
+                Box::new(upgrade.reject().map(|_| None).map_err(|e| e.into()))
+            };
+            f
+        })
+        // get rid of the bad connections
+        .filter_map(|i| i)
+        // send a greeting!
+        .and_then(|s| s.send(Message::text("Hello World!").into()))
+        // simple echo server impl
+        .and_then(|s| {
+            let (sink, stream) = s.split();
+            stream.filter_map(|m| {
+                println!("Message from Client: {:?}", m);
+                match m {
+                    OwnedMessage::Ping(p) => Some(OwnedMessage::Pong(p)),
+                    OwnedMessage::Pong(_) => None,
+                    _ => Some(m),
+                }
+            }).forward(sink)
+        })
+        // TODO: ??
+        .collect();
+
+	core.run(f).unwrap();
+}

examples/autobahn-server.rs

@@ -1,7 +1,9 @@
 extern crate websocket;
 
 use std::thread;
-use websocket::{Server, Message, OwnedMessage};
+use websocket::{Message, OwnedMessage};
+use websocket::sync::Server;
+
 
 fn main() {
 	let server = Server::bind("127.0.0.1:9002").unwrap();

examples/hyper.rs

@@ -3,7 +3,8 @@ extern crate hyper;
 
 use std::thread;
 use std::io::Write;
-use websocket::{Server, Message, OwnedMessage};
+use websocket::{Message, OwnedMessage};
+use websocket::sync::Server;
 use hyper::Server as HttpServer;
 use hyper::net::Fresh;
 use hyper::server::request::Request;

examples/server.rs

@@ -1,7 +1,8 @@
 extern crate websocket;
 
 use std::thread;
-use websocket::{Server, OwnedMessage};
+use websocket::OwnedMessage;
+use websocket::sync::Server;
 
 fn main() {
 	let server = Server::bind("127.0.0.1:2794").unwrap();

src/lib.rs

@@ -112,11 +112,13 @@ pub mod sync {
 		pub use server::upgrade::sync::IntoWs;
 		pub use server::upgrade::sync as upgrade;
 	}
+	pub use server::sync::Server;
 
 	pub mod client {
 		pub use client::sync::*;
 		pub use client::builder::ClientBuilder;
 	}
+	pub use client::sync::Client;
 }
 
 #[cfg(feature="async")]
@@ -136,16 +138,21 @@ pub mod async {
 		pub use server::upgrade::async::IntoWs;
 		pub use server::upgrade::async as upgrade;
 	}
+	pub use server::async::Server;
 
 	pub mod client {
 		pub use client::async::*;
 		pub use client::builder::ClientBuilder;
 	}
+	pub use client::async::Client;
+
+	pub use result::async::WebSocketFuture;
 }
 
 pub use self::message::Message;
 pub use self::message::CloseData;
 pub use self::message::OwnedMessage;
+pub use self::client::builder::ClientBuilder;
 
 pub use self::result::WebSocketError;
 pub use self::result::WebSocketResult;