Bundle max upload and max unpack size into one struct

To get rid of a clippy too many arguments warning; also nice to extract
the knowledge of how these get decided to one place

Author: carols10cents

src/controllers/krate/publish.rs

@@ -1,6 +1,5 @@
 //! Functionality related to publishing a new crate or version of a crate.
 
-use std::cmp;
 use std::collections::HashMap;
 use std::sync::Arc;
 
@@ -9,7 +8,7 @@ use serde_json;
 
 use git;
 use render;
-use util::{internal, ChainError};
+use util::{internal, ChainError, Maximums};
 use util::{read_fill, read_le_u32};
 
 use controllers::prelude::*;
@@ -111,12 +110,18 @@ pub fn publish(req: &mut dyn Request) -> CargoResult<Response> {
         let content_length = req
             .content_length()
             .chain_error(|| human("missing header: Content-Length"))?;
-        let max = krate
-            .max_upload_size
-            .map(|m| m as u64)
-            .unwrap_or(app.config.max_upload_size);
-        if content_length > max {
-            return Err(human(&format_args!("max upload size is: {}", max)));
+
+        let maximums = Maximums::new(
+            krate.max_upload_size,
+            app.config.max_upload_size,
+            app.config.max_unpack_size,
+        );
+
+        if content_length > maximums.max_upload_size {
+            return Err(human(&format_args!(
+                "max upload size is: {}",
+                maximums.max_upload_size
+            )));
         }
 
         // This is only redundant for now. Eventually the duplication will be removed.
@@ -162,16 +167,10 @@ pub fn publish(req: &mut dyn Request) -> CargoResult<Response> {
         // Upload the crate, return way to delete the crate from the server
         // If the git commands fail below, we shouldn't keep the crate on the
         // server.
-        let max_unpack = cmp::max(app.config.max_unpack_size, max);
-        let (cksum, mut crate_bomb, mut readme_bomb) = app.config.uploader.upload_crate(
-            req,
-            &krate,
-            readme,
-            file_length,
-            max,
-            max_unpack,
-            vers,
-        )?;
+        let (cksum, mut crate_bomb, mut readme_bomb) =
+            app.config
+                .uploader
+                .upload_crate(req, &krate, readme, file_length, maximums, vers)?;
         version.record_readme_rendering(&conn)?;
 
         let mut hex_cksum = String::new();

src/uploaders.rs

@@ -7,7 +7,7 @@ use semver;
 use tar;
 
 use util::LimitErrorReader;
-use util::{human, internal, CargoResult, ChainError};
+use util::{human, internal, CargoResult, ChainError, Maximums};
 
 use std::env;
 use std::fs::{self, File};
@@ -162,16 +162,15 @@ impl Uploader {
         krate: &Crate,
         readme: Option<String>,
         file_length: u32,
-        max: u64,
-        max_unpack: u64,
+        maximums: Maximums,
         vers: &semver::Version,
     ) -> CargoResult<(Vec<u8>, Bomb, Bomb)> {
         let app = Arc::clone(req.app());
         let (crate_path, checksum) = {
             let path = Uploader::crate_path(&krate.name, &vers.to_string());
             let mut body = Vec::new();
-            LimitErrorReader::new(req.body(), max).read_to_end(&mut body)?;
-            verify_tarball(krate, vers, &body, max_unpack)?;
+            LimitErrorReader::new(req.body(), maximums.max_upload_size).read_to_end(&mut body)?;
+            verify_tarball(krate, vers, &body, maximums.max_unpack_size)?;
             self.upload(
                 app.handle(),
                 &path,

src/util/mod.rs

@@ -1,3 +1,4 @@
+use std::cmp;
 use std::collections::HashMap;
 use std::io::Cursor;
 
@@ -32,3 +33,24 @@ pub fn json_response<T: Serialize>(t: &T) -> Response {
         body: Box::new(Cursor::new(json.into_bytes())),
     }
 }
+
+#[derive(Debug, Copy, Clone)]
+pub struct Maximums {
+    pub max_upload_size: u64,
+    pub max_unpack_size: u64,
+}
+
+impl Maximums {
+    pub fn new(
+        krate_max_upload: Option<i32>,
+        app_max_upload: u64,
+        app_max_unpack: u64,
+    ) -> Maximums {
+        let max_upload_size = krate_max_upload.map(|m| m as u64).unwrap_or(app_max_upload);
+        let max_unpack_size = cmp::max(app_max_unpack, max_upload_size);
+        Maximums {
+            max_upload_size,
+            max_unpack_size,
+        }
+    }
+}