Don't reduce memory limit if override is less than default

Author: Nemo157

src/db/migrate.rs

@@ -286,11 +286,16 @@ pub fn migrate(version: Option<Version>, conn: &mut Client) -> crate::error::Res
             // version
             7,
             // description
-            "Allow memory limits of more than 4 GB",
+            "Allow memory limits of more than 2 GB",
             // upgrade query
             "ALTER TABLE sandbox_overrides ALTER COLUMN max_memory_bytes TYPE BIGINT;",
             // downgrade query
-            "ALTER TABLE sandbox_overrides ALTER COLUMN max_memory_bytes TYPE INTEGER;"
+            "
+                ALTER TABLE sandbox_overrides
+                    ALTER COLUMN max_memory_bytes
+                    TYPE INTEGER
+                    USING least(max_memory_bytes, 2147483647);
+            "
         ),
         sql_migration!(
             context,

src/docbuilder/limits.rs

@@ -30,7 +30,10 @@ impl Limits {
         let default = Self::new(config);
         let overrides = Overrides::for_crate(conn, name)?.unwrap_or_default();
         Ok(Self {
-            memory: overrides.memory.unwrap_or(default.memory),
+            memory: overrides
+                .memory
+                .unwrap_or(default.memory)
+                .max(default.memory),
             targets: overrides
                 .targets
                 .or(overrides.timeout.map(|_| 1))
@@ -72,10 +75,12 @@ mod test {
         wrapper(|env| {
             let db = env.db();
 
+            let defaults = Limits::new(&env.config());
+
             let krate = "hexponent";
             // limits work if no crate has limits set
             let hexponent = Limits::for_crate(&env.config(), &mut db.conn(), krate)?;
-            assert_eq!(hexponent, Limits::new(&env.config()));
+            assert_eq!(hexponent, defaults);
 
             Overrides::save(
                 &mut db.conn(),
@@ -91,17 +96,17 @@ mod test {
                 hexponent,
                 Limits {
                     targets: 15,
-                    ..Limits::new(&env.config())
+                    ..defaults
                 }
             );
 
             // all limits work
             let krate = "regex";
             let limits = Limits {
-                memory: 100_000,
-                timeout: Duration::from_secs(300),
+                memory: defaults.memory * 2,
+                timeout: defaults.timeout * 2,
                 targets: 1,
-                ..Limits::new(&env.config())
+                ..defaults
             };
             Overrides::save(
                 &mut db.conn(),
@@ -155,4 +160,27 @@ mod test {
             Ok(())
         });
     }
+
+    #[test]
+    fn overrides_dont_lower_memory_limit() {
+        wrapper(|env| {
+            let db = env.db();
+
+            let defaults = Limits::new(&env.config());
+
+            Overrides::save(
+                &mut db.conn(),
+                "krate",
+                Overrides {
+                    memory: Some(defaults.memory / 2),
+                    ..Overrides::default()
+                },
+            )?;
+
+            let limits = Limits::for_crate(&env.config(), &mut db.conn(), "krate")?;
+            assert_eq!(limits, defaults);
+
+            Ok(())
+        });
+    }
 }

src/web/builds.rs

@@ -291,7 +291,7 @@ mod tests {
                  VALUES ($1, $2, $3, $4)",
                 &[
                     &"foo",
-                    &3072i64,
+                    &(6 * 1024 * 1024 * 1024i64),
                     &(Duration::hours(2).num_seconds() as i32),
                     &1,
                 ],
@@ -315,7 +315,7 @@ mod tests {
             let values: Vec<_> = values.iter().map(|v| &**v).collect();
 
             dbg!(&values);
-            assert!(values.contains(&"3 KB"));
+            assert!(values.contains(&"6 GB"));
             assert!(values.contains(&"2 hours"));
             assert!(values.contains(&"100 KB"));
             assert!(values.contains(&"blocked"));