Revert "Error, ctry! and cexpect!"

This reverts commit d5a1127.

Author: Joshua Nelson

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");
+    }
 }

src/web/builds.rs

@@ -38,17 +38,15 @@ impl_webpage! {
 
 pub fn build_list_handler(req: &mut Request) -> IronResult<Response> {
     let router = extension!(req, Router);
-    let name = cexpect!(req, router.find("name"));
-    let version = cexpect!(req, router.find("version"));
+    let name = cexpect!(router.find("name"));
+    let version = cexpect!(router.find("version"));
     let req_build_id: i32 = router.find("id").unwrap_or("0").parse().unwrap_or(0);
 
     let conn = extension!(req, Pool).get()?;
-    let limits = ctry!(req, Limits::for_crate(&conn, name));
+    let limits = ctry!(Limits::for_crate(&conn, name));
 
-    let query = ctry!(
-        req,
-        conn.query(
-            "SELECT crates.name,
+    let query = ctry!(conn.query(
+        "SELECT crates.name,
                 releases.version,
                 releases.description,
                 releases.rustdoc_status,
@@ -64,9 +62,8 @@ pub fn build_list_handler(req: &mut Request) -> IronResult<Response> {
          INNER JOIN crates ON releases.crate_id = crates.id
          WHERE crates.name = $1 AND releases.version = $2
          ORDER BY id DESC",
-            &[&name, &version]
-        )
-    );
+        &[&name, &version]
+    ));
 
     let mut build_log = None;
     // FIXME: getting builds.output may cause performance issues when release have tons of builds

src/web/crate_details.rs

@@ -356,7 +356,7 @@ fn map_to_release(conn: &Connection, crate_id: i32, version: String) -> Release
 pub fn crate_details_handler(req: &mut Request) -> IronResult<Response> {
     let router = extension!(req, Router);
     // this handler must always called with a crate name
-    let name = cexpect!(req, router.find("name"));
+    let name = cexpect!(router.find("name"));
     let req_version = router.find("version");
 
     let conn = extension!(req, Pool).get()?;
@@ -372,15 +372,9 @@ pub fn crate_details_handler(req: &mut Request) -> IronResult<Response> {
                 .to_resp("crate_details")
         }
         Some(MatchSemver::Semver((version, _))) => {
-            let url = ctry!(
-                req,
-                Url::parse(&format!(
-                    "{}/crate/{}/{}",
-                    redirect_base(req),
-                    name,
-                    version
-                )),
-            );
+            let url = ctry!(Url::parse(
+                &format!("{}/crate/{}/{}", redirect_base(req), name, version)[..]
+            ));
 
             Ok(super::redirect(url))
         }

src/web/error.rs

@@ -1,9 +1,12 @@
 use crate::{
     db::PoolError,
-    web::{page::WebPage, releases::Search, ErrorPage},
+    web::{
+        page::{Page, WebPage},
+        releases::Search,
+    },
 };
 use failure::Fail;
-use iron::{status::Status, Handler, IronError, IronResult, Plugin, Request, Response};
+use iron::{status, Handler, IronError, IronResult, Plugin, Request, Response};
 use params::{Params, Value};
 use std::{error::Error, fmt};
 
@@ -33,24 +36,18 @@ impl Handler for Nope {
         match *self {
             Nope::ResourceNotFound => {
                 // user tried to navigate to a resource (doc page/file) that doesn't exist
-                // TODO: Display the attempted page
-                ErrorPage {
-                    title: "The requested resource does not exist".into(),
-                    message: Some("no such resource".into()),
-                    status: Status::NotFound,
-                }
-                .into_response(req)
+                Page::new("no such resource".to_owned())
+                    .set_status(status::NotFound)
+                    .title("The requested resource does not exist")
+                    .to_resp("error")
             }
 
             Nope::CrateNotFound => {
                 // user tried to navigate to a crate that doesn't exist
-                // TODO: Display the attempted crate and a link to a search for said crate
-                ErrorPage {
-                    title: "The requested crate does not exist".into(),
-                    message: Some("no such crate".into()),
-                    status: Status::NotFound,
-                }
-                .into_response(req)
+                Page::new("no such crate".to_owned())
+                    .set_status(status::NotFound)
+                    .title("The requested crate does not exist")
+                    .to_resp("error")
             }
 
             Nope::NoResults => {
@@ -61,15 +58,15 @@ impl Handler for Nope {
                     Search {
                         title: format!("No crates found matching '{}'", query),
                         search_query: Some(query.to_owned()),
-                        status: Status::NotFound,
+                        status: status::NotFound,
                         ..Default::default()
                     }
                     .into_response(req)
                 } else {
                     // user did a search with no search terms
                     Search {
                         title: "No results given for empty search query".to_owned(),
-                        status: Status::NotFound,
+                        status: status::NotFound,
                         ..Default::default()
                     }
                     .into_response(req)
@@ -78,19 +75,17 @@ impl Handler for Nope {
 
             Nope::InternalServerError => {
                 // something went wrong, details should have been logged
-                ErrorPage {
-                    title: "Internal server error".into(),
-                    message: Some("internal server error".into()),
-                    status: Status::InternalServerError,
-                }
-                .into_response(req)
+                Page::new("internal server error".to_owned())
+                    .set_status(status::InternalServerError)
+                    .title("Internal server error")
+                    .to_resp("error")
             }
         }
     }
 }
 
 impl From<PoolError> for IronError {
     fn from(err: PoolError) -> IronError {
-        IronError::new(err.compat(), Status::InternalServerError)
+        IronError::new(err.compat(), status::InternalServerError)
     }
 }

src/web/metrics.rs

@@ -154,9 +154,9 @@ pub fn metrics_handler(req: &mut Request) -> IronResult<Response> {
     USED_DB_CONNECTIONS.set(pool.used_connections() as i64);
     IDLE_DB_CONNECTIONS.set(pool.idle_connections() as i64);
 
-    QUEUED_CRATES_COUNT.set(ctry!(req, queue.pending_count()) as i64);
-    PRIORITIZED_CRATES_COUNT.set(ctry!(req, queue.prioritized_count()) as i64);
-    FAILED_CRATES_COUNT.set(ctry!(req, queue.failed_count()) as i64);
+    QUEUED_CRATES_COUNT.set(ctry!(queue.pending_count()) as i64);
+    PRIORITIZED_CRATES_COUNT.set(ctry!(queue.prioritized_count()) as i64);
+    FAILED_CRATES_COUNT.set(ctry!(queue.failed_count()) as i64);
 
     #[cfg(target_os = "linux")]
     {
@@ -169,12 +169,12 @@ pub fn metrics_handler(req: &mut Request) -> IronResult<Response> {
 
     let mut buffer = Vec::new();
     let families = prometheus::gather();
-    ctry!(req, TextEncoder::new().encode(&families, &mut buffer));
+    ctry!(TextEncoder::new().encode(&families, &mut buffer));
 
     let mut resp = Response::with(buffer);
     resp.status = Some(Status::Ok);
-    resp.headers.set(ContentType::plaintext());
-
+    resp.headers
+        .set(ContentType("text/plain; version=0.0.4".parse().unwrap()));
     Ok(resp)
 }