Revert "The rest of Tera"

Cargo.toml

@@ -54,6 +54,7 @@ serde_json = "1.0"
 # iron dependencies
 iron = "0.5"
 router = "0.5"
+handlebars-iron = "0.25"
 params = "0.8"
 staticfile = { version = "0.4", features = [ "cache" ] }
 tempfile = "3.1.0"

dockerfiles/Dockerfile

@@ -74,6 +74,7 @@ RUN mkdir -p /opt/docsrs/prefix
 COPY --from=build /build/target/release/cratesfyi /usr/local/bin
 COPY static /opt/docsrs/prefix/public_html
 COPY templates /opt/docsrs/templates
+COPY tera-templates /opt/docsrs/tera-templates
 COPY dockerfiles/entrypoint.sh /opt/docsrs/
 
 WORKDIR /opt/docsrs

src/build_queue.rs

@@ -3,7 +3,7 @@ use crate::db::Pool;
 use crate::error::Result;
 use log::error;
 
-#[derive(Debug, Clone, Eq, PartialEq, serde::Serialize)]
+#[derive(Debug, Eq, PartialEq, serde::Serialize)]
 pub(crate) struct QueuedCrate {
     #[serde(skip)]
     id: i32,

src/docbuilder/limits.rs

@@ -1,7 +1,7 @@
 use crate::error::Result;
 use postgres::Connection;
 use serde::Serialize;
-use std::time::Duration;
+use std::{collections::BTreeMap, time::Duration};
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize)]
 pub(crate) struct Limits {
@@ -67,6 +67,52 @@ impl Limits {
     pub(crate) fn targets(&self) -> usize {
         self.targets
     }
+
+    pub(crate) fn for_website(&self) -> BTreeMap<String, String> {
+        let mut res = BTreeMap::new();
+        res.insert("Available RAM".into(), SIZE_SCALE(self.memory));
+        res.insert(
+            "Maximum rustdoc execution time".into(),
+            TIME_SCALE(self.timeout.as_secs() as usize),
+        );
+        res.insert(
+            "Maximum size of a build log".into(),
+            SIZE_SCALE(self.max_log_size),
+        );
+        if self.networking {
+            res.insert("Network access".into(), "allowed".into());
+        } else {
+            res.insert("Network access".into(), "blocked".into());
+        }
+        res.insert(
+            "Maximum number of build targets".into(),
+            self.targets.to_string(),
+        );
+        res
+    }
+}
+
+const TIME_SCALE: fn(usize) -> String = |v| scale(v, 60, &["seconds", "minutes", "hours"]);
+const SIZE_SCALE: fn(usize) -> String = |v| scale(v, 1024, &["bytes", "KB", "MB", "GB"]);
+
+fn scale(value: usize, interval: usize, labels: &[&str]) -> String {
+    let (mut value, interval) = (value as f64, interval as f64);
+    let mut chosen_label = &labels[0];
+    for label in &labels[1..] {
+        if value / interval >= 1.0 {
+            chosen_label = label;
+            value /= interval;
+        } else {
+            break;
+        }
+    }
+    // 2.x
+    let mut value = format!("{:.1}", value);
+    // 2.0 -> 2
+    if value.ends_with(".0") {
+        value.truncate(value.len() - 2);
+    }
+    format!("{} {}", value, chosen_label)
 }
 
 #[cfg(test)]
@@ -115,4 +161,56 @@ mod test {
             Ok(())
         });
     }
+
+    #[test]
+    fn display_limits() {
+        let limits = Limits {
+            memory: 102_400,
+            timeout: Duration::from_secs(300),
+            targets: 1,
+            ..Limits::default()
+        };
+        let display = limits.for_website();
+        assert_eq!(display.get("Network access"), Some(&"blocked".into()));
+        assert_eq!(
+            display.get("Maximum size of a build log"),
+            Some(&"100 KB".into())
+        );
+        assert_eq!(
+            display.get("Maximum number of build targets"),
+            Some(&limits.targets.to_string())
+        );
+        assert_eq!(
+            display.get("Maximum rustdoc execution time"),
+            Some(&"5 minutes".into())
+        );
+        assert_eq!(display.get("Available RAM"), Some(&"100 KB".into()));
+    }
+
+    #[test]
+    fn scale_limits() {
+        // time
+        assert_eq!(TIME_SCALE(300), "5 minutes");
+        assert_eq!(TIME_SCALE(1), "1 seconds");
+        assert_eq!(TIME_SCALE(7200), "2 hours");
+
+        // size
+        assert_eq!(SIZE_SCALE(1), "1 bytes");
+        assert_eq!(SIZE_SCALE(100), "100 bytes");
+        assert_eq!(SIZE_SCALE(1024), "1 KB");
+        assert_eq!(SIZE_SCALE(10240), "10 KB");
+        assert_eq!(SIZE_SCALE(1_048_576), "1 MB");
+        assert_eq!(SIZE_SCALE(10_485_760), "10 MB");
+        assert_eq!(SIZE_SCALE(1_073_741_824), "1 GB");
+        assert_eq!(SIZE_SCALE(10_737_418_240), "10 GB");
+        assert_eq!(SIZE_SCALE(std::u32::MAX as usize), "4 GB");
+
+        // fractional sizes
+        assert_eq!(TIME_SCALE(90), "1.5 minutes");
+        assert_eq!(TIME_SCALE(5400), "1.5 hours");
+
+        assert_eq!(SIZE_SCALE(1_288_490_189), "1.2 GB");
+        assert_eq!(SIZE_SCALE(3_758_096_384), "3.5 GB");
+        assert_eq!(SIZE_SCALE(1_048_051_712), "999.5 MB");
+    }
 }