Even more improvements (#119)

* Exposing protocols. More core methods.

* From implementation for MiddlewareAction.

Author: tomusdrw

core/src/io.rs

@@ -164,25 +164,7 @@ impl<T: Metadata, S: Middleware<T>> MetaIoHandler<T, S> {
 		let request = read_request(request);
 		let result = match request {
 			Err(error) => futures::finished(Some(Response::from(error, self.compatibility.default_version()))).boxed(),
-			Ok(request) => self.middleware.on_request(request, meta, |request, meta| match request {
-				Request::Single(call) => {
-					self.handle_call(call, meta)
-						.map(|output| output.map(Response::Single))
-						.boxed()
-				},
-				Request::Batch(calls) => {
-					let futures: Vec<_> = calls.into_iter().map(move |call| self.handle_call(call, meta.clone())).collect();
-					futures::future::join_all(futures).map(|outs| {
-						let outs: Vec<_> = outs.into_iter().filter_map(|v| v).collect();
-						if outs.is_empty() {
-							None
-						} else {
-							Some(Response::Batch(outs))
-						}
-					})
-					.boxed()
-				},
-			}),
+			Ok(request) => self.handle_rpc_request(request, meta),
 		};
 
 		result.map(|response| {
@@ -192,6 +174,29 @@ impl<T: Metadata, S: Middleware<T>> MetaIoHandler<T, S> {
 		}).boxed()
 	}
 
+	/// Handle deserialized RPC request.
+	pub fn handle_rpc_request(&self, request: Request, meta: T) -> FutureResponse {
+		self.middleware.on_request(request, meta, |request, meta| match request {
+			Request::Single(call) => {
+				self.handle_call(call, meta)
+					.map(|output| output.map(Response::Single))
+					.boxed()
+			},
+			Request::Batch(calls) => {
+				let futures: Vec<_> = calls.into_iter().map(move |call| self.handle_call(call, meta.clone())).collect();
+				futures::future::join_all(futures).map(|outs| {
+					let outs: Vec<_> = outs.into_iter().filter_map(|v| v).collect();
+					if outs.is_empty() {
+						None
+					} else {
+						Some(Response::Batch(outs))
+					}
+				})
+				.boxed()
+			},
+		})
+	}
+
 	/// Handle single call asynchronously.
 	pub fn handle_call(&self, call: Call, meta: T) -> BoxFuture<Option<Output>, ()> {
 		match call {
@@ -261,11 +266,21 @@ impl IoHandler {
 }
 
 impl<M: Metadata> IoHandler<M> {
-	/// Handle given request asynchronously.
+	/// Handle given string request asynchronously.
 	pub fn handle_request(&self, request: &str) -> BoxFuture<Option<String>, ()> {
 		self.0.handle_request(request, M::default())
 	}
 
+	/// Handle deserialized RPC request asynchronously.
+	pub fn handle_rpc_request(&self, request: Request) -> FutureResponse {
+		self.0.handle_rpc_request(request, M::default())
+	}
+
+	/// Handle single Call asynchronously.
+	pub fn handle_call(&self, call: Call) -> BoxFuture<Option<Output>, ()> {
+		self.0.handle_call(call, M::default())
+	}
+
 	/// Handle given request synchronously - will block until response is available.
 	/// If you have any asynchronous methods in your RPC it is much wiser to use
 	/// `handle_request` instead and deal with asynchronous requests in a non-blocking fashion.

ws/src/metadata.rs

@@ -1,3 +1,5 @@
+use std::fmt;
+
 use core;
 use ws;
 
@@ -10,10 +12,22 @@ pub struct RequestContext {
 	pub session_id: session::SessionId,
 	/// Request Origin
 	pub origin: Option<Origin>,
+	/// Requested protocols
+	pub protocols: Vec<String>,
 	/// Direct channel to send messages to a client.
 	pub out: ws::Sender,
 }
 
+impl fmt::Debug for RequestContext {
+	fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+		fmt.debug_struct("RequestContext")
+			.field("session_id", &self.session_id)
+			.field("origin", &self.origin)
+			.field("protocols", &self.protocols)
+			.finish()
+	}
+}
+
 /// Metadata extractor from session data.
 pub trait MetaExtractor<M: core::Metadata>: Send + Sync + 'static {
 	/// Extract metadata for given session

ws/src/session.rs

@@ -34,10 +34,7 @@ impl<F> RequestMiddleware for F where
 	F: Fn(&ws::Request) -> Option<ws::Response> + Send + Sync + 'static,
 {
 	fn process(&self, req: &ws::Request) -> MiddlewareAction {
-		match (*self)(req) {
-			Some(res) => MiddlewareAction::Respond { response: res, validate_origin: true, validate_hosts: true },
-			None => MiddlewareAction::Proceed,
-		}
+		(*self)(req).into()
 	}
 }
 
@@ -76,6 +73,15 @@ impl MiddlewareAction {
 	}
 }
 
+impl From<Option<ws::Response>> for MiddlewareAction {
+	fn from(opt: Option<ws::Response>) -> Self {
+		match opt {
+			Some(res) => MiddlewareAction::Respond { response: res, validate_origin: true, validate_hosts: true },
+			None => MiddlewareAction::Proceed,
+		}
+	}
+}
+
 pub struct Session<M: core::Metadata, S: core::Middleware<M>> {
 	context: metadata::RequestContext,
 	handler: Arc<core::MetaIoHandler<M, S>>,
@@ -150,10 +156,18 @@ impl<M: core::Metadata, S: core::Middleware<M>> ws::Handler for Session<M, S> {
 		}
 
 		self.context.origin = origin.and_then(|origin| ::std::str::from_utf8(origin).ok()).map(Into::into);
+		self.context.protocols = req.protocols().ok()
+			.map(|protos| protos.into_iter().map(Into::into).collect())
+			.unwrap_or_else(Vec::new);
 		self.metadata = self.meta_extractor.extract(&self.context);
 
 		match action {
-			MiddlewareAction::Proceed => ws::Response::from_request(req),
+			MiddlewareAction::Proceed => ws::Response::from_request(req).map(|mut res| {
+				if let Some(protocol) = self.context.protocols.get(0) {
+					res.set_protocol(protocol);
+				}
+				res
+			}),
 			MiddlewareAction::Respond { response, .. } => Ok(response),
 		}
 	}
@@ -223,6 +237,7 @@ impl<M: core::Metadata, S: core::Middleware<M>> ws::Factory for Factory<M, S> {
 			context: metadata::RequestContext {
 				session_id: self.session_id,
 				origin: None,
+				protocols: Vec::new(),
 				out: sender,
 			},
 			handler: self.handler.clone(),