add tokio (0.2) as dependency to further async-ify our FromData code

i'm using this opportunity to also update reqwest (0.10), but it's
turning out to be a little trickier, as it requires more modern async
setup, and that appears to need a lot of thinking…

src/api/mod.rs

@@ -27,20 +27,20 @@ impl From<std::option::NoneError> for ApiError {
 }
 
 impl<'r> Responder<'r> for ApiError {
-    fn respond_to(self, req: &Request<'_>) -> response::Result<'r> {
+    fn respond_to(self, req: &'r Request) -> response::ResultFuture<'r> {
         match self.0 {
             Error::NotFound => Json(json!({
                 "error": "Not found"
             }))
-            .respond_to(req),
+                .respond_to(req),
             Error::Unauthorized => Json(json!({
                 "error": "You are not authorized to access this resource"
             }))
-            .respond_to(req),
+                .respond_to(req),
             _ => Json(json!({
                 "error": "Server error"
             }))
-            .respond_to(req),
+                .respond_to(req),
         }
     }
 }

src/inbox.rs

@@ -73,32 +73,32 @@ impl<'a, T: Deserialize<'a>> FromData<'a> for SignedJson<T> {
     type Owned = String;
     type Borrowed = str;
 
-    fn transform(
-        r: &Request<'_>,
-        d: Data,
-    ) -> Transform<rocket::data::Outcome<Self::Owned, Self::Error>> {
-        let size_limit = r.limits().get("json").unwrap_or(JSON_LIMIT);
-        let mut s = String::with_capacity(512);
-        match d.open().take(size_limit).read_to_string(&mut s) {
-            Ok(_) => Transform::Borrowed(Success(s)),
-            Err(e) => Transform::Borrowed(Failure((Status::BadRequest, JsonError::Io(e)))),
-        }
+    fn transform<'r>(
+        r: &'r Request,
+        d: Data
+    ) -> TransformFuture<'r, Self::Owned, Self::Error> {
+        Box::pin(async move {
+            let size_limit = r.limits().get("json").unwrap_or(JSON_LIMIT);
+            let mut s = String::with_capacity(512);
+            let outcome = match d.open().take(size_limit).read_to_string(&mut s) {
+                Ok(_) => Success(s),
+                Err(e) => Failure((Status::BadRequest, JsonError::Io(e))),
+            };
+            Transform::Borrowed(outcome)
+        })
     }
 
     fn from_data(
         _: &Request<'_>,
         o: Transformed<'a, Self>,
-    ) -> rocket::data::Outcome<Self, Self::Error> {
-        let string = o.borrowed()?;
-        match serde_json::from_str(&string) {
-            Ok(v) => Success(SignedJson(Digest::from_body(&string), Json(v))),
-            Err(e) => {
-                if e.is_data() {
-                    Failure((Status::UnprocessableEntity, JsonError::Parse(string, e)))
-                } else {
-                    Failure((Status::BadRequest, JsonError::Parse(string, e)))
-                }
+    ) -> FromDataFuture<'a, Self, Self::Error> {
+        Box::pin(async move {
+            let string = try_outcome!(o.borrowed());
+            match serde_json::from_str(&string) {
+                Ok(v) => Success(SignedJson(Digest::from_body(&string), Json(v))),
+                Err(e) if e.is_data() => return Failure((Status::UnprocessableEntity, JsonError::Parse(string, e))),
+                Err(e) => Failure((Status::BadRequest, JsonError::Parse(string, e))),
             }
-        }
+        })
     }
 }