upgrade all cargo dependencies

Unfortunately we need to pull tracing-opentelemetry from git because
there hasn't been a release including the dependency bump on the other
opentelemetry crates.

src/api/ruma_wrapper/axum.rs

@@ -2,19 +2,22 @@ use std::{collections::BTreeMap, iter::FromIterator, str};
 
 use axum::{
     async_trait,
-    body::{Full, HttpBody},
-    extract::{
-        rejection::TypedHeaderRejectionReason, FromRequest, Path, TypedHeader,
-    },
+    body::Body,
+    extract::{FromRequest, Path},
+    response::{IntoResponse, Response},
+    RequestExt, RequestPartsExt,
+};
+use axum_extra::{
     headers::{
         authorization::{Bearer, Credentials},
         Authorization,
     },
-    response::{IntoResponse, Response},
-    BoxError, RequestExt, RequestPartsExt,
+    typed_header::TypedHeaderRejectionReason,
+    TypedHeader,
 };
-use bytes::{Buf, BufMut, Bytes, BytesMut};
+use bytes::{BufMut, BytesMut};
 use http::{Request, StatusCode};
+use http_body_util::BodyExt;
 use ruma::{
     api::{
         client::error::ErrorKind, AuthScheme, IncomingRequest, OutgoingResponse,
@@ -35,18 +38,15 @@ enum Token {
 }
 
 #[async_trait]
-impl<T, S, B> FromRequest<S, B> for Ar<T>
+impl<T, S> FromRequest<S> for Ar<T>
 where
     T: IncomingRequest,
-    B: HttpBody + Send + 'static,
-    B::Data: Send,
-    B::Error: Into<BoxError>,
 {
     type Rejection = Error;
 
     #[allow(clippy::too_many_lines)]
     async fn from_request(
-        req: Request<B>,
+        req: axum::extract::Request,
         _state: &S,
     ) -> Result<Self, Self::Rejection> {
         #[derive(Deserialize)]
@@ -55,21 +55,17 @@ where
             user_id: Option<String>,
         }
 
-        let (mut parts, mut body) = match req.with_limited_body() {
-            Ok(limited_req) => {
-                let (parts, body) = limited_req.into_parts();
-                let body = to_bytes(body).await.map_err(|_| {
+        let (mut parts, mut body) = {
+            let limited_req = req.with_limited_body();
+            let (parts, body) = limited_req.into_parts();
+            let body = body
+                .collect()
+                .await
+                .map_err(|_| {
                     Error::BadRequest(ErrorKind::MissingToken, "Missing token.")
-                })?;
-                (parts, body)
-            }
-            Err(original_req) => {
-                let (parts, body) = original_req.into_parts();
-                let body = to_bytes(body).await.map_err(|_| {
-                    Error::BadRequest(ErrorKind::MissingToken, "Missing token.")
-                })?;
-                (parts, body)
-            }
+                })?
+                .to_bytes();
+            (parts, body)
         };
 
         let metadata = T::METADATA;
@@ -151,7 +147,7 @@ where
 
                     if !services().users.exists(&user_id)? {
                         return Err(Error::BadRequest(
-                            ErrorKind::Forbidden,
+                            ErrorKind::forbidden(),
                             "User does not exist.",
                         ));
                     }
@@ -196,7 +192,7 @@ where
                                 _ => "Unknown header-related error",
                             };
 
-                            Error::BadRequest(ErrorKind::Forbidden, msg)
+                            Error::BadRequest(ErrorKind::forbidden(), msg)
                         })?;
 
                     let origin_signatures = BTreeMap::from_iter([(
@@ -261,7 +257,7 @@ where
                         Err(e) => {
                             warn!("Failed to fetch signing keys: {}", e);
                             return Err(Error::BadRequest(
-                                ErrorKind::Forbidden,
+                                ErrorKind::forbidden(),
                                 "Failed to fetch signing keys.",
                             ));
                         }
@@ -294,7 +290,7 @@ where
                             }
 
                             return Err(Error::BadRequest(
-                                ErrorKind::Forbidden,
+                                ErrorKind::forbidden(),
                                 "Failed to verify X-Matrix signatures.",
                             ));
                         }
@@ -453,62 +449,10 @@ impl Credentials for XMatrix {
 impl<T: OutgoingResponse> IntoResponse for Ra<T> {
     fn into_response(self) -> Response {
         match self.0.try_into_http_response::<BytesMut>() {
-            Ok(res) => res.map(BytesMut::freeze).map(Full::new).into_response(),
+            Ok(res) => {
+                res.map(BytesMut::freeze).map(Body::from).into_response()
+            }
             Err(_) => StatusCode::INTERNAL_SERVER_ERROR.into_response(),
         }
     }
 }
-
-// copied from hyper under the following license:
-// Copyright (c) 2014-2021 Sean McArthur
-
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-pub(crate) async fn to_bytes<T>(body: T) -> Result<Bytes, T::Error>
-where
-    T: HttpBody,
-{
-    futures_util::pin_mut!(body);
-
-    // If there's only 1 chunk, we can just return Buf::to_bytes()
-    let mut first = if let Some(buf) = body.data().await {
-        buf?
-    } else {
-        return Ok(Bytes::new());
-    };
-
-    let second = if let Some(buf) = body.data().await {
-        buf?
-    } else {
-        return Ok(first.copy_to_bytes(first.remaining()));
-    };
-
-    // With more than 1 buf, we gotta flatten into a Vec first.
-    let cap = first.remaining()
-        + second.remaining()
-        + body.size_hint().lower().try_into().unwrap_or(usize::MAX);
-    let mut vec = Vec::with_capacity(cap);
-    vec.put(first);
-    vec.put(second);
-
-    while let Some(buf) = body.data().await {
-        vec.put(buf?);
-    }
-
-    Ok(vec.into())
-}