ConduitRequest: Remove Cursor wrapper

conduit-axum/src/conduit.rs

@@ -5,7 +5,6 @@ use axum::{async_trait, RequestExt};
 use http_body::LengthLimitError;
 use hyper::Body;
 use std::error::Error;
-use std::io::Cursor;
 use std::ops::{Deref, DerefMut};
 
 use crate::response::AxumResponse;
@@ -31,10 +30,10 @@ pub fn box_error<E: Error + Send + 'static>(error: E) -> BoxError {
 }
 
 #[derive(Debug)]
-pub struct ConduitRequest(pub Request<Cursor<Bytes>>);
+pub struct ConduitRequest(pub Request<Bytes>);
 
 impl Deref for ConduitRequest {
-    type Target = Request<Cursor<Bytes>>;
+    type Target = Request<Bytes>;
 
     fn deref(&self) -> &Self::Target {
         &self.0
@@ -80,6 +79,6 @@ where
             }
         };
 
-        Ok(ConduitRequest(request.map(Cursor::new)))
+        Ok(ConduitRequest(request))
     }
 }

src/controllers/crate_owner_invitation.rs

@@ -258,10 +258,10 @@ struct OwnerInvitation {
 }
 
 /// Handles the `PUT /api/v1/me/crate_owner_invitations/:crate_id` route.
-pub async fn handle_invite(mut req: ConduitRequest) -> AppResult<Json<Value>> {
+pub async fn handle_invite(req: ConduitRequest) -> AppResult<Json<Value>> {
     conduit_compat(move || {
-        let crate_invite: OwnerInvitation = serde_json::from_reader(req.body_mut())
-            .map_err(|_| bad_request("invalid json request"))?;
+        let crate_invite: OwnerInvitation =
+            serde_json::from_slice(req.body()).map_err(|_| bad_request("invalid json request"))?;
 
         let crate_invite = crate_invite.crate_owner_invite;
 

src/controllers/krate/owners.rs

@@ -5,8 +5,8 @@ use crate::controllers::prelude::*;
 use crate::models::token::EndpointScope;
 use crate::models::{Crate, Owner, Rights, Team, User};
 use crate::views::EncodableOwner;
+use axum::body::Bytes;
 use http::Request;
-use std::io::Read;
 
 /// Handles the `GET /crates/:crate_id/owners` route.
 pub async fn owners(Path(crate_name): Path<String>, req: ConduitRequest) -> AppResult<Json<Value>> {
@@ -63,17 +63,17 @@ pub async fn owner_user(
 /// Handles the `PUT /crates/:crate_id/owners` route.
 pub async fn add_owners(
     Path(crate_name): Path<String>,
-    mut req: ConduitRequest,
+    req: ConduitRequest,
 ) -> AppResult<Json<Value>> {
-    conduit_compat(move || modify_owners(&crate_name, &mut req, true)).await
+    conduit_compat(move || modify_owners(&crate_name, &req, true)).await
 }
 
 /// Handles the `DELETE /crates/:crate_id/owners` route.
 pub async fn remove_owners(
     Path(crate_name): Path<String>,
-    mut req: ConduitRequest,
+    req: ConduitRequest,
 ) -> AppResult<Json<Value>> {
-    conduit_compat(move || modify_owners(&crate_name, &mut req, false)).await
+    conduit_compat(move || modify_owners(&crate_name, &req, false)).await
 }
 
 /// Parse the JSON request body of requests to modify the owners of a crate.
@@ -83,26 +83,22 @@ pub async fn remove_owners(
 /// ```json
 /// {"owners": ["username", "github:org:team", ...]}
 /// ```
-fn parse_owners_request<B: Read>(req: &mut Request<B>) -> AppResult<Vec<String>> {
+fn parse_owners_request(req: &Request<Bytes>) -> AppResult<Vec<String>> {
     #[derive(Deserialize)]
     struct Request {
         // identical, for back-compat (owners preferred)
         users: Option<Vec<String>>,
         owners: Option<Vec<String>>,
     }
     let request: Request =
-        serde_json::from_reader(req.body_mut()).map_err(|_| cargo_err("invalid json request"))?;
+        serde_json::from_slice(req.body()).map_err(|_| cargo_err("invalid json request"))?;
     request
         .owners
         .or(request.users)
         .ok_or_else(|| cargo_err("invalid json request"))
 }
 
-fn modify_owners<B: Read>(
-    crate_name: &str,
-    req: &mut Request<B>,
-    add: bool,
-) -> AppResult<Json<Value>> {
+fn modify_owners(crate_name: &str, req: &Request<Bytes>, add: bool) -> AppResult<Json<Value>> {
     let logins = parse_owners_request(req)?;
     let app = req.app();
 

src/controllers/krate/publish.rs

@@ -46,8 +46,7 @@ pub const WILDCARD_ERROR_MESSAGE: &str = "wildcard (`*`) dependency constraints
 /// threads and return completion or error through other methods  a `cargo publish
 /// --status` command, via crates.io's front end, or email.
 pub async fn publish(req: ConduitRequest) -> AppResult<Json<GoodCrate>> {
-    let (req, body) = req.0.into_parts();
-    let bytes = body.into_inner();
+    let (req, bytes) = req.0.into_parts();
     let (json_bytes, tarball_bytes) = split_body(bytes, &req)?;
 
     let new_crate: EncodableCrateUpload = serde_json::from_slice(&json_bytes)

src/controllers/token.rs

@@ -26,7 +26,7 @@ pub async fn list(req: ConduitRequest) -> AppResult<Json<Value>> {
 }
 
 /// Handles the `PUT /me/tokens` route.
-pub async fn new(mut req: ConduitRequest) -> AppResult<Json<Value>> {
+pub async fn new(req: ConduitRequest) -> AppResult<Json<Value>> {
     conduit_compat(move || {
         /// The incoming serialization format for the `ApiToken` model.
         #[derive(Deserialize, Serialize)]
@@ -40,7 +40,7 @@ pub async fn new(mut req: ConduitRequest) -> AppResult<Json<Value>> {
             api_token: NewApiToken,
         }
 
-        let new: NewApiTokenRequest = json::from_reader(req.body_mut())
+        let new: NewApiTokenRequest = json::from_slice(req.body())
             .map_err(|e| bad_request(&format!("invalid new token request: {e:?}")))?;
 
         let name = &new.api_token.name;

src/controllers/user/me.rs

@@ -101,7 +101,7 @@ pub async fn updates(req: ConduitRequest) -> AppResult<Json<Value>> {
 /// Handles the `PUT /users/:user_id` route.
 pub async fn update_user(
     Path(param_user_id): Path<i32>,
-    mut req: ConduitRequest,
+    req: ConduitRequest,
 ) -> AppResult<Response> {
     conduit_compat(move || {
         use self::emails::user_id;
@@ -128,8 +128,8 @@ pub async fn update_user(
             email: Option<String>,
         }
 
-        let user_update: UserUpdate = serde_json::from_reader(req.body_mut())
-            .map_err(|_| bad_request("invalid json request"))?;
+        let user_update: UserUpdate =
+            serde_json::from_slice(req.body()).map_err(|_| bad_request("invalid json request"))?;
 
         let user_email = match &user_update.user.email {
             Some(email) => email.trim(),
@@ -231,7 +231,7 @@ pub async fn regenerate_token_and_send(
 }
 
 /// Handles `PUT /me/email_notifications` route
-pub async fn update_email_notifications(mut req: ConduitRequest) -> AppResult<Response> {
+pub async fn update_email_notifications(req: ConduitRequest) -> AppResult<Response> {
     conduit_compat(move || {
         use self::crate_owners::dsl::*;
         use diesel::pg::upsert::excluded;
@@ -243,7 +243,7 @@ pub async fn update_email_notifications(mut req: ConduitRequest) -> AppResult<Re
         }
 
         let updates: HashMap<i32, bool> =
-            serde_json::from_reader::<_, Vec<CrateEmailNotifications>>(req.body_mut())
+            serde_json::from_slice::<Vec<CrateEmailNotifications>>(req.body())
                 .map_err(|_| bad_request("invalid json request"))?
                 .iter()
                 .map(|c| (c.id, c.email_notifications))