Merge remote-tracking branch 'origin/master' into split_in_two

Conflicts:
	src/client/builder.rs
	src/result.rs

Author: vi

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "websocket"
-version = "0.22.4"
+version = "0.23.0"
 authors = ["cyderize <[email protected]>", "Michael Eden <[email protected]>"]
 
 description = "A WebSocket (RFC6455) library for Rust."

README.md

@@ -1,6 +1,11 @@
 Rust-WebSocket [![Build Status](https://travis-ci.com/websockets-rs/rust-websocket.svg?branch=master)](https://travis-ci.com/websockets-rs/rust-websocket) [![docs.rs](https://docs.rs/websocket/badge.svg)](https://docs.rs/websocket)
 ==============
 
+
+|**Note: Maintainership of this project is slugglish. You may want to use [tungstenite](https://crates.io/crates/tungstenite) or [tokio-tungstenite](https://crates.io/crates/tokio-tungstenite) instead.**|
+|----|
+
+
 Rust-WebSocket is a WebSocket ([RFC6455](https://datatracker.ietf.org/doc/rfc6455/)) library written in Rust.
 
 Rust-WebSocket provides a framework for dealing with WebSocket connections (both clients and servers). The library is currently in an experimental state, but provides functionality for both normal and secure WebSockets, a message level API supporting fragmentation, a data frame level API, and the ability to extend and customize behaviour.
@@ -10,7 +15,7 @@ Rust-WebSocket provides a framework for dealing with WebSocket connections (both
 To add a library release version from [crates.io](https://crates.io/crates/websocket) to a Cargo project, add this to the 'dependencies' section of your Cargo.toml:
 
 ```INI
-websocket = "0.22.4"
+websocket = "0.23.0"
 ```
 
 To add the library's Git repository to a Cargo project, add this to your Cargo.toml:

examples/async-client.rs

@@ -13,56 +13,69 @@ use websocket::{ClientBuilder, OwnedMessage};
 
 const CONNECTION: &'static str = "ws://127.0.0.1:2794";
 
+// Async websocket chat client
 fn main() {
 	println!("Connecting to {}", CONNECTION);
+
+	// Construct new Tokio runtime environment
 	let mut runtime = tokio::runtime::current_thread::Builder::new()
 		.build()
 		.unwrap();
 
-	// standard in isn't supported in mio yet, so we use a thread
-	// see https://github.com/carllerche/mio/issues/321
 	let (usr_msg, stdin_ch) = mpsc::channel(0);
+
+	// Spawn new thread to read user input
+	// stdin isn't supported in mio yet, so we use a thread
+	// see https://github.com/carllerche/mio/issues/321
 	thread::spawn(|| {
 		let mut input = String::new();
 		let mut stdin_sink = usr_msg.wait();
 		loop {
+			// Read user input from stdin
 			input.clear();
 			stdin().read_line(&mut input).unwrap();
+			
+			// Trim whitespace and match input to known chat commands
+			// If input is unknown, send trimmed input as a chat message 
 			let trimmed = input.trim();
-
 			let (close, msg) = match trimmed {
 				"/close" => (true, OwnedMessage::Close(None)),
 				"/ping" => (false, OwnedMessage::Ping(b"PING".to_vec())),
 				_ => (false, OwnedMessage::Text(trimmed.to_string())),
 			};
-
+			// Send message to websocket server
 			stdin_sink
 				.send(msg)
 				.expect("Sending message across stdin channel.");
-
+			// If user entered the "/close" command, break the loop
 			if close {
 				break;
 			}
 		}
 	});
 
+	// Construct a new connection to the websocket server 
 	let runner = ClientBuilder::new(CONNECTION)
 		.unwrap()
 		.add_protocol("rust-websocket")
 		.async_connect_insecure()
 		.and_then(|(duplex, _)| {
 			let (sink, stream) = duplex.split();
 			stream
+				// Iterate over message as they arrive in stream
 				.filter_map(|message| {
 					println!("Received Message: {:?}", message);
+					// Respond to close or ping commands from the server
 					match message {
-						OwnedMessage::Close(e) => Some(OwnedMessage::Close(e)),
 						OwnedMessage::Ping(d) => Some(OwnedMessage::Pong(d)),
 						_ => None,
 					}
 				})
+				// Takes in messages from both sinks
 				.select(stdin_ch.map_err(|_| WebSocketError::NoDataAvailable))
+				// Return a future that completes once all incoming data from the above streams has been processed into the sink
 				.forward(sink)
 		});
+	// Start our websocket client runner in the Tokio environment
 	runtime.block_on(runner).unwrap();
 }

src/client/builder.rs

@@ -2,7 +2,7 @@
 
 use header::extensions::Extension;
 use header::{Origin, WebSocketExtensions, WebSocketKey, WebSocketProtocol, WebSocketVersion};
-use hyper::header::{Header, HeaderFormat, Headers};
+use hyper::header::{Authorization, Basic, Header, HeaderFormat, Headers};
 use hyper::version::HttpVersion;
 use std::borrow::Cow;
 use std::convert::Into;
@@ -820,6 +820,17 @@ impl<'u> ClientBuilder<'u> {
 			});
 		}
 
+		// handle username/password from URL
+		if !self.url.username().is_empty() {
+			self.headers.set(Authorization(Basic {
+				username: self.url.username().to_owned(),
+				password: match self.url.password() {
+					Some(password) => Some(password.to_owned()),
+					None => None,
+				},
+			}));
+		}
+
 		self.headers
 			.set(Connection(vec![ConnectionOption::ConnectionHeader(
 				UniCase("Upgrade".to_string()),
@@ -847,10 +858,7 @@ impl<'u> ClientBuilder<'u> {
 		let status = StatusCode::from_u16(response.subject.0);
 
 		if status != StatusCode::SwitchingProtocols {
-			return Err(WebSocketOtherError::ResponseError(
-				"Status code must be Switching Protocols",
-			))
-			.map_err(towse);
+			return Err(WebSocketOtherError::StatusCodeError(status));
 		}
 
 		let key = self
@@ -989,4 +997,14 @@ mod tests {
 		assert!(protos.contains(&"electric".to_string()));
 		assert!(!protos.contains(&"rust-websocket".to_string()));
 	}
+
+	#[test]
+	fn build_client_with_username_password() {
+		use super::*;
+		let mut builder = ClientBuilder::new("ws://john:[email protected]:8080/hello").unwrap();
+		let _request = builder.build_request();
+		let auth = builder.headers.get::<Authorization<Basic>>().unwrap();
+		assert!(auth.username == "john");
+		assert_eq!(auth.password, Some("pswd".to_owned()));
+	}
 }

src/result.rs

@@ -1,5 +1,6 @@
 //! The result type used within Rust-WebSocket
 
+pub use hyper::status::StatusCode;
 use hyper::Error as HttpError;
 use server::upgrade::HyperIntoWsError;
 use std::convert::From;
@@ -40,6 +41,8 @@ pub enum WebSocketOtherError {
 	RequestError(&'static str),
 	/// Invalid WebSocket response error
 	ResponseError(&'static str),
+	/// Received unexpected status code
+	StatusCodeError(StatusCode),
 	/// An HTTP parsing error
 	HttpError(HttpError),
 	/// A URL parsing error
@@ -83,6 +86,7 @@ impl Error for WebSocketOtherError {
 			WebSocketOtherError::WebSocketUrlError(_) => "WebSocket URL failure",
 			WebSocketOtherError::IoError(ref e) => e.description(),
 			WebSocketOtherError::ProtocolError(e) => e,
+			WebSocketOtherError::StatusCodeError(_) => "Received unexpected status code",
 		}
 	}