web: remove the TEMPLATE_DATA static

Author: pietroalbini

src/bin/cratesfyi.rs

@@ -90,9 +90,11 @@ impl CommandLine {
                 socket_addr,
                 reload_templates,
             } => {
-                Server::start(Some(&socket_addr), reload_templates, config);
+                Server::start(Some(&socket_addr), reload_templates, config)?;
+            }
+            Self::Daemon { foreground } => {
+                cratesfyi::utils::start_daemon(!foreground, config)?;
             }
-            Self::Daemon { foreground } => cratesfyi::utils::start_daemon(!foreground, config),
             Self::Database { subcommand } => subcommand.handle_args(),
             Self::Queue { subcommand } => subcommand.handle_args(),
         }

src/test/mod.rs

@@ -212,7 +212,8 @@ pub(crate) struct TestFrontend {
 impl TestFrontend {
     fn new(db: &TestDatabase, config: Arc<Config>) -> Self {
         Self {
-            server: Server::start_test(db.conn.clone(), config),
+            server: Server::start_test(db.conn.clone(), config)
+                .expect("failed to start the server"),
             client: Client::new(),
         }
     }

src/utils/daemon.rs

@@ -8,6 +8,7 @@ use crate::{
     Config, DocBuilder, DocBuilderOptions,
 };
 use chrono::{Timelike, Utc};
+use failure::Error;
 use log::{debug, error, info, warn};
 use std::panic::{catch_unwind, AssertUnwindSafe};
 use std::path::PathBuf;
@@ -18,7 +19,7 @@ use std::{env, thread};
 #[cfg(not(target_os = "windows"))]
 use ::{libc::fork, std::fs::File, std::io::Write, std::process::exit};
 
-pub fn start_daemon(background: bool, config: Arc<Config>) {
+pub fn start_daemon(background: bool, config: Arc<Config>) -> Result<(), Error> {
     const CRATE_VARIABLES: [&str; 3] = [
         "CRATESFYI_PREFIX",
         "CRATESFYI_GITHUB_USERNAME",
@@ -250,7 +251,8 @@ pub fn start_daemon(background: bool, config: Arc<Config>) {
     // at least start web server
     info!("Starting web server");
 
-    crate::Server::start(None, false, config);
+    crate::Server::start(None, false, config)?;
+    Ok(())
 }
 
 fn opts() -> DocBuilderOptions {

src/web/mod.rs

@@ -55,9 +55,11 @@ mod rustdoc;
 mod sitemap;
 mod source;
 
+use self::page::TemplateData;
 use self::pool::Pool;
 use crate::config::Config;
 use chrono::{DateTime, Utc};
+use failure::Error;
 use handlebars_iron::{DirectorySource, HandlebarsEngine, SourceError};
 use iron::headers::{CacheControl, CacheDirective, ContentType, Expires, HttpDate};
 use iron::modifiers::Redirect;
@@ -112,8 +114,12 @@ impl CratesfyiHandler {
         chain
     }
 
-    fn new(pool: Pool, config: Arc<Config>) -> CratesfyiHandler {
-        let inject_extensions = InjectExtensions { pool, config };
+    fn new(pool: Pool, config: Arc<Config>, template_data: Arc<TemplateData>) -> CratesfyiHandler {
+        let inject_extensions = InjectExtensions {
+            pool,
+            config,
+            template_data,
+        };
 
         let routes = routes::build_routes();
         let blacklisted_prefixes = routes.page_prefixes();
@@ -215,12 +221,15 @@ impl Handler for CratesfyiHandler {
 struct InjectExtensions {
     pool: Pool,
     config: Arc<Config>,
+    template_data: Arc<TemplateData>,
 }
 
 impl BeforeMiddleware for InjectExtensions {
     fn before(&self, req: &mut Request) -> IronResult<()> {
         req.extensions.insert::<Pool>(self.pool.clone());
         req.extensions.insert::<Config>(self.config.clone());
+        req.extensions
+            .insert::<TemplateData>(self.template_data.clone());
 
         Ok(())
     }
@@ -383,24 +392,46 @@ pub struct Server {
 }
 
 impl Server {
-    pub fn start(addr: Option<&str>, reload_templates: bool, config: Arc<Config>) -> Self {
+    pub fn start(
+        addr: Option<&str>,
+        reload_templates: bool,
+        config: Arc<Config>,
+    ) -> Result<Self, Error> {
         // Initialize templates
-        let _: &page::TemplateData = &*page::TEMPLATE_DATA;
+        let template_data = Arc::new(TemplateData::new()?);
         if reload_templates {
-            page::TemplateData::start_template_reloading();
+            TemplateData::start_template_reloading(template_data.clone());
         }
 
-        let server = Self::start_inner(addr.unwrap_or(DEFAULT_BIND), Pool::new(), config);
+        let server = Self::start_inner(
+            addr.unwrap_or(DEFAULT_BIND),
+            Pool::new(),
+            config,
+            template_data,
+        );
         info!("Running docs.rs web server on http://{}", server.addr());
-        server
+        Ok(server)
     }
 
     #[cfg(test)]
-    pub(crate) fn start_test(conn: Arc<Mutex<Connection>>, config: Arc<Config>) -> Self {
-        Self::start_inner("127.0.0.1:0", Pool::new_simple(conn.clone()), config)
+    pub(crate) fn start_test(
+        conn: Arc<Mutex<Connection>>,
+        config: Arc<Config>,
+    ) -> Result<Self, Error> {
+        Ok(Self::start_inner(
+            "127.0.0.1:0",
+            Pool::new_simple(conn.clone()),
+            config,
+            Arc::new(TemplateData::new()?),
+        ))
     }
 
-    fn start_inner(addr: &str, pool: Pool, config: Arc<Config>) -> Self {
+    fn start_inner(
+        addr: &str,
+        pool: Pool,
+        config: Arc<Config>,
+        template_data: Arc<TemplateData>,
+    ) -> Self {
         // poke all the metrics counters to instantiate and register them
         metrics::TOTAL_BUILDS.inc_by(0);
         metrics::SUCCESSFUL_BUILDS.inc_by(0);
@@ -409,7 +440,7 @@ impl Server {
         metrics::UPLOADED_FILES_TOTAL.inc_by(0);
         metrics::FAILED_DB_CONNECTIONS.inc_by(0);
 
-        let cratesfyi = CratesfyiHandler::new(pool, config);
+        let cratesfyi = CratesfyiHandler::new(pool, config, template_data);
         let inner = Iron::new(cratesfyi)
             .http(addr)
             .unwrap_or_else(|_| panic!("Failed to bind to socket on {}", addr));

src/web/page/mod.rs

@@ -8,11 +8,6 @@ pub(crate) use web_page::WebPage;
 
 use serde::Serialize;
 
-lazy_static::lazy_static! {
-    /// Holds all data relevant to templating
-    pub(crate) static ref TEMPLATE_DATA: TemplateData = TemplateData::new().expect("Failed to load template data");
-}
-
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize)]
 pub(crate) struct GlobalAlert {
     pub(crate) url: &'static str,

src/web/page/templates.rs

@@ -1,19 +1,24 @@
 use crate::error::Result;
 use arc_swap::ArcSwap;
 use chrono::{DateTime, Utc};
+use notify::{watcher, RecursiveMode, Watcher};
 use serde_json::Value;
 use std::collections::HashMap;
+use std::sync::{mpsc::channel, Arc};
+use std::thread;
+use std::time::Duration;
 use tera::{Result as TeraResult, Tera};
 
 /// Holds all data relevant to templating
+#[derive(Debug)]
 pub(crate) struct TemplateData {
     /// The actual templates, stored in an `ArcSwap` so that they're hot-swappable
     // TODO: Conditional compilation so it's not always wrapped, the `ArcSwap` is unneeded overhead for prod
     pub templates: ArcSwap<Tera>,
 }
 
 impl TemplateData {
-    pub fn new() -> Result<Self> {
+    pub(crate) fn new() -> Result<Self> {
         log::trace!("Loading templates");
 
         let data = Self {
@@ -25,14 +30,7 @@ impl TemplateData {
         Ok(data)
     }
 
-    pub fn start_template_reloading() {
-        use notify::{watcher, RecursiveMode, Watcher};
-        use std::{
-            sync::{mpsc::channel, Arc},
-            thread,
-            time::Duration,
-        };
-
+    pub(crate) fn start_template_reloading(template_data: Arc<TemplateData>) {
         let (tx, rx) = channel();
         // Set a 2 second event debounce for the watcher
         let mut watcher = watcher(tx, Duration::from_secs(2)).unwrap();
@@ -50,7 +48,7 @@ impl TemplateData {
                 match load_templates() {
                     Ok(templates) => {
                         log::info!("Reloaded templates");
-                        super::TEMPLATE_DATA.templates.swap(Arc::new(templates));
+                        template_data.templates.swap(Arc::new(templates));
                     }
 
                     Err(err) => log::error!("Error reloading templates: {:?}", err),
@@ -60,6 +58,10 @@ impl TemplateData {
     }
 }
 
+impl iron::typemap::Key for TemplateData {
+    type Value = std::sync::Arc<TemplateData>;
+}
+
 // TODO: Is there a reason this isn't fatal? If the rustc version is incorrect (Or "???" as used by default), then
 //       all pages will be served *really* weird because they'll lack all CSS
 fn load_rustc_resource_suffix() -> Result<String> {

src/web/page/web_page.rs

@@ -1,5 +1,5 @@
-use super::TEMPLATE_DATA;
-use iron::{headers::ContentType, response::Response, status::Status, IronResult};
+use super::TemplateData;
+use iron::{headers::ContentType, response::Response, status::Status, IronResult, Request};
 use serde::Serialize;
 use tera::Context;
 
@@ -28,9 +28,13 @@ macro_rules! impl_webpage {
 pub trait WebPage: Serialize + Sized {
     /// Turn the current instance into a `Response`, ready to be served
     // TODO: We could cache similar pages using the `&Context`
-    fn into_response(self) -> IronResult<Response> {
+    fn into_response(self, req: &Request) -> IronResult<Response> {
         let ctx = Context::from_serialize(&self).unwrap();
-        let rendered = TEMPLATE_DATA
+
+        let rendered = req
+            .extensions
+            .get::<TemplateData>()
+            .expect("missing TemplateData from the request extensions")
             .templates
             .load()
             .render(Self::TEMPLATE, &ctx)

src/web/sitemap.rs

@@ -49,7 +49,7 @@ pub fn sitemap_handler(req: &mut Request) -> IronResult<Response> {
         })
         .collect::<Vec<(String, String)>>();
 
-    SitemapXml { releases }.into_response()
+    SitemapXml { releases }.into_response(req)
 }
 
 pub fn robots_txt_handler(_: &mut Request) -> IronResult<Response> {
@@ -83,5 +83,5 @@ pub fn about_handler(req: &mut Request) -> IronResult<Response> {
         rustc_version,
         limits: Limits::default(),
     }
-    .into_response()
+    .into_response(req)
 }