Error, ctry! and cexpect!

Author: Kixiron

src/docbuilder/limits.rs

@@ -1,7 +1,7 @@
 use crate::error::Result;
 use postgres::Connection;
 use serde::Serialize;
-use std::{collections::BTreeMap, time::Duration};
+use std::{time::Duration};
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize)]
 pub(crate) struct Limits {
@@ -67,52 +67,6 @@ 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)]
@@ -161,56 +115,4 @@ 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,15 +38,17 @@ impl_webpage! {
 
 pub fn build_list_handler(req: &mut Request) -> IronResult<Response> {
     let router = extension!(req, Router);
-    let name = cexpect!(router.find("name"));
-    let version = cexpect!(router.find("version"));
+    let name = cexpect!(req, router.find("name"));
+    let version = cexpect!(req, 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!(Limits::for_crate(&conn, name));
+    let limits = ctry!(req, Limits::for_crate(&conn, name));
 
-    let query = ctry!(conn.query(
-        "SELECT crates.name,
+    let query = ctry!(
+        req,
+        conn.query(
+            "SELECT crates.name,
                 releases.version,
                 releases.description,
                 releases.rustdoc_status,
@@ -62,8 +64,9 @@ 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!(router.find("name"));
+    let name = cexpect!(req, router.find("name"));
     let req_version = router.find("version");
 
     let conn = extension!(req, Pool).get()?;
@@ -372,9 +372,15 @@ pub fn crate_details_handler(req: &mut Request) -> IronResult<Response> {
                 .to_resp("crate_details")
         }
         Some(MatchSemver::Semver((version, _))) => {
-            let url = ctry!(Url::parse(
-                &format!("{}/crate/{}/{}", redirect_base(req), name, version)[..]
-            ));
+            let url = ctry!(
+                req,
+                Url::parse(&format!(
+                    "{}/crate/{}/{}",
+                    redirect_base(req),
+                    name,
+                    version
+                )),
+            );
 
             Ok(super::redirect(url))
         }

src/web/error.rs

@@ -1,12 +1,9 @@
 use crate::{
     db::PoolError,
-    web::{
-        page::{Page, WebPage},
-        releases::Search,
-    },
+    web::{page::WebPage, releases::Search, ErrorPage},
 };
 use failure::Fail;
-use iron::{status, Handler, IronError, IronResult, Plugin, Request, Response};
+use iron::{status::Status, Handler, IronError, IronResult, Plugin, Request, Response};
 use params::{Params, Value};
 use std::{error::Error, fmt};
 
@@ -36,18 +33,24 @@ impl Handler for Nope {
         match *self {
             Nope::ResourceNotFound => {
                 // user tried to navigate to a resource (doc page/file) that doesn't exist
-                Page::new("no such resource".to_owned())
-                    .set_status(status::NotFound)
-                    .title("The requested resource does not exist")
-                    .to_resp("error")
+                // 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)
             }
 
             Nope::CrateNotFound => {
                 // user tried to navigate to a crate that doesn't exist
-                Page::new("no such crate".to_owned())
-                    .set_status(status::NotFound)
-                    .title("The requested crate does not exist")
-                    .to_resp("error")
+                // 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)
             }
 
             Nope::NoResults => {
@@ -58,15 +61,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)
@@ -75,17 +78,19 @@ impl Handler for Nope {
 
             Nope::InternalServerError => {
                 // something went wrong, details should have been logged
-                Page::new("internal server error".to_owned())
-                    .set_status(status::InternalServerError)
-                    .title("Internal server error")
-                    .to_resp("error")
+                ErrorPage {
+                    title: "Internal server error".into(),
+                    message: Some("internal server error".into()),
+                    status: Status::InternalServerError,
+                }
+                .into_response(req)
             }
         }
     }
 }
 
 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!(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);
+    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);
 
     #[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!(TextEncoder::new().encode(&families, &mut buffer));
+    ctry!(req, TextEncoder::new().encode(&families, &mut buffer));
 
     let mut resp = Response::with(buffer);
     resp.status = Some(Status::Ok);
-    resp.headers
-        .set(ContentType("text/plain; version=0.0.4".parse().unwrap()));
+    resp.headers.set(ContentType::plaintext());
+
     Ok(resp)
 }