Support Context<T> in async code.

Author: tmpfs

examples/async.rs

@@ -1,12 +1,16 @@
-use json_rpc2::{Request, Response, Result, futures::*};
-use serde_json::Value;
 use async_trait::async_trait;
+use json_rpc2::{futures::*, Context, Request, Response, Result};
+use serde_json::Value;
 
 struct ServiceHandler;
 
 #[async_trait]
-impl Service for ServiceHandler {
-    async fn handle(&self, req: &mut Request) -> Result<Option<Response>> {
+impl<T: Send + Sync> Service<T> for ServiceHandler {
+    async fn handle(
+        &self,
+        req: &mut Request,
+        _ctx: &Context<T>,
+    ) -> Result<Option<Response>> {
         let mut response = None;
         if req.matches("hello") {
             let params: String = req.deserialize()?;
@@ -19,10 +23,11 @@ impl Service for ServiceHandler {
 
 #[tokio::main]
 async fn main() -> Result<()> {
-    let service: Box<dyn Service> = Box::new(ServiceHandler {});
-    let mut request = Request::new("hello", Some(Value::String("world".to_string())));
-    let services = vec![&service];
-    let response = serve(&services, &mut request).await;
+    let service: Box<dyn Service<()>> = Box::new(ServiceHandler {});
+    let mut request =
+        Request::new("hello", Some(Value::String("world".to_string())));
+    let server = Server::new(vec![&service]);
+    let response = server.serve(&mut request, &Default::default()).await;
     println!("{:?}", response.result());
     assert_eq!(
         Some(Value::String("Hello, world!".to_string())),

examples/hello-world.rs

@@ -3,7 +3,11 @@ use serde_json::Value;
 
 struct ServiceHandler;
 impl<T> Service<T> for ServiceHandler {
-    fn handle(&self, request: &mut Request, _context: &Context<T>) -> Result<Option<Response>> {
+    fn handle(
+        &self,
+        request: &mut Request,
+        _ctx: &Context<T>,
+    ) -> Result<Option<Response>> {
         let mut response = None;
         if request.matches("hello") {
             let params: String = request.deserialize()?;
@@ -16,9 +20,10 @@ impl<T> Service<T> for ServiceHandler {
 
 fn main() -> Result<()> {
     let service: Box<dyn Service<()>> = Box::new(ServiceHandler {});
-    let mut request = Request::new("hello", Some(Value::String("world".to_string())));
-    let services = vec![&service];
-    let response = serve(&services, &mut request);
+    let mut request =
+        Request::new("hello", Some(Value::String("world".to_string())));
+    let server = Server::new(vec![&service]);
+    let response = server.serve(&mut request, &Default::default());
     println!("{:?}", response.result());
     assert_eq!(
         Some(Value::String("Hello, world!".to_string())),

rustfmt.toml

@@ -0,0 +1,2 @@
+edition = "2018"
+max_width = 80

src/futures.rs

@@ -1,43 +1,63 @@
 //! Non-blocking implementation, requires the `async` feature.
 
-use crate::{Request, Response, Error, Result};
+use crate::{Context, Error, Request, Response, Result};
 use async_trait::async_trait;
 
 #[async_trait]
 /// Trait for async services that maybe handle a request.
-pub trait Service {
+pub trait Service<T: Send + Send> {
     /// See [Service](crate::Service) for more information.
-    async fn handle(&self, req: &mut Request) -> Result<Option<Response>>;
+    async fn handle(
+        &self,
+        request: &mut Request,
+        ctx: &Context<T>,
+    ) -> Result<Option<Response>>;
 }
 
-/// Call async services in order and return the first response message.
-///
-/// See [handle](crate::handle) for more information.
-pub async fn handle<'a>(
-    services: &'a Vec<&'a Box<dyn Service>>,
-    request: &mut Request,
-) -> Result<Response> {
-    for service in services {
-        if let Some(result) = service.handle(request).await? {
-            return Ok(result);
-        }
+/// Serve requests.
+pub struct Server<'a, T: Send + Sync> {
+    /// Services that the server should invoke for every request.
+    services: Vec<&'a Box<dyn Service<T>>>,
+}
+
+impl<'a, T: Send + Sync> Server<'a, T> {
+    /// Create a new server.
+    pub fn new(services: Vec<&'a Box<dyn Service<T>>>) -> Self {
+        Self {services} 
     }
 
-    let err = Error::MethodNotFound {
-        name: request.method().to_string(),
-        id: request.id.clone(),
-    };
+    /// Call services in order and return the first response message.
+    ///
+    /// If no services match the incoming request this will
+    /// return a `Error::MethodNotFound`.
+    pub(crate) async fn handle(
+        &self,
+        request: &mut Request,
+        ctx: &Context<T>,
+    ) -> Result<Response> {
+        for service in self.services.iter() {
+            if let Some(result) = service.handle(request, ctx).await? {
+                return Ok(result);
+            }
+        }
+
+        let err = Error::MethodNotFound {
+            name: request.method().to_string(),
+            id: request.id.clone(),
+        };
 
-    Ok((request, err).into())
-}
+        Ok((request, err).into())
+    }
 
-/// Infallible async service handler, errors are automatically converted to responses.
-pub async fn serve<'a>(
-    services: &'a Vec<&'a Box<dyn Service>>,
-    request: &mut Request,
-) -> Response {
-     match handle(services, request).await {
-        Ok(response) => response,
-        Err(e) => e.into(),
+    /// Infallible service handler, errors are automatically converted to responses.
+    pub async fn serve(
+        &self,
+        request: &mut Request,
+        ctx: &Context<T>,
+    ) -> Response {
+        match self.handle(request, ctx).await {
+            Ok(response) => response,
+            Err(e) => e.into(),
+        }
     }
 }