docbuilder: remove DocBuilderOptions

Author: pietroalbini

src/bin/cratesfyi.rs

@@ -7,8 +7,7 @@ use cratesfyi::db::{self, add_path_into_database, Pool, PoolClient};
 use cratesfyi::index::Index;
 use cratesfyi::utils::{remove_crate_priority, set_crate_priority};
 use cratesfyi::{
-    BuildQueue, Config, Context, DocBuilder, DocBuilderOptions, Metrics, RustwideBuilder, Server,
-    Storage,
+    BuildQueue, Config, Context, DocBuilder, Metrics, RustwideBuilder, Server, Storage,
 };
 use failure::{err_msg, Error, ResultExt};
 use once_cell::sync::OnceCell;
@@ -230,31 +229,13 @@ struct Build {
     #[structopt(name = "SKIP_IF_EXISTS", short = "s", long = "skip")]
     skip_if_exists: bool,
 
-    /// Skips building documentation if build log exists
-    #[structopt(name = "SKIP_IF_LOG_EXISTS", long = "skip-if-log-exists")]
-    skip_if_log_exists: bool,
-
     #[structopt(subcommand)]
     subcommand: BuildSubcommand,
 }
 
 impl Build {
     pub fn handle_args(self, ctx: BinContext) -> Result<(), Error> {
-        let docbuilder = {
-            let config = ctx.config()?;
-            let mut doc_options =
-                DocBuilderOptions::new(config.prefix.clone(), config.registry_index_path.clone());
-
-            doc_options.skip_if_exists = self.skip_if_exists;
-
-            doc_options
-                .check_paths()
-                .context("The given paths were invalid")?;
-
-            DocBuilder::new(doc_options, ctx.pool()?, ctx.build_queue()?)
-        };
-
-        self.subcommand.handle_args(ctx, docbuilder)
+        self.subcommand.handle_args(ctx, self.skip_if_exists)
     }
 }
 
@@ -297,19 +278,17 @@ enum BuildSubcommand {
 
     /// Unlocks cratesfyi daemon to continue building new crates
     Unlock,
-
-    PrintOptions,
 }
 
 impl BuildSubcommand {
-    pub fn handle_args(self, ctx: BinContext, mut docbuilder: DocBuilder) -> Result<(), Error> {
+    pub fn handle_args(self, ctx: BinContext, skip_if_exists: bool) -> Result<(), Error> {
+        let mut docbuilder = DocBuilder::new(ctx.config()?, ctx.pool()?, ctx.build_queue()?);
+
         let rustwide_builder = || -> Result<RustwideBuilder, Error> {
-            Ok(RustwideBuilder::init(
-                ctx.config()?,
-                ctx.pool()?,
-                ctx.metrics()?,
-                ctx.storage()?,
-            )?)
+            let mut builder =
+                RustwideBuilder::init(ctx.config()?, ctx.pool()?, ctx.metrics()?, ctx.storage()?)?;
+            builder.set_skip_build_if_exists(skip_if_exists);
+            Ok(builder)
         };
 
         match self {
@@ -371,7 +350,6 @@ impl BuildSubcommand {
 
             Self::Lock => docbuilder.lock().context("Failed to lock")?,
             Self::Unlock => docbuilder.unlock().context("Failed to unlock")?,
-            Self::PrintOptions => println!("{:?}", docbuilder.options()),
         }
 
         Ok(())

src/docbuilder/mod.rs

@@ -1,6 +1,5 @@
 mod crates;
 mod limits;
-pub(crate) mod options;
 mod queue;
 mod rustwide_builder;
 
@@ -11,33 +10,32 @@ pub(crate) use self::rustwide_builder::{BuildResult, DocCoverage};
 use crate::db::Pool;
 use crate::error::Result;
 use crate::index::Index;
-use crate::BuildQueue;
-use crate::DocBuilderOptions;
+use crate::{BuildQueue, Config};
 use std::fs;
 use std::path::PathBuf;
 use std::sync::Arc;
 
 /// chroot based documentation builder
 pub struct DocBuilder {
-    options: DocBuilderOptions,
+    config: Arc<Config>,
     index: Index,
     db: Pool,
     build_queue: Arc<BuildQueue>,
 }
 
 impl DocBuilder {
-    pub fn new(options: DocBuilderOptions, db: Pool, build_queue: Arc<BuildQueue>) -> DocBuilder {
-        let index = Index::new(&options.registry_index_path).expect("valid index");
+    pub fn new(config: Arc<Config>, db: Pool, build_queue: Arc<BuildQueue>) -> DocBuilder {
+        let index = Index::new(&config.registry_index_path).expect("valid index");
         DocBuilder {
+            config,
             build_queue,
-            options,
             index,
             db,
         }
     }
 
     fn lock_path(&self) -> PathBuf {
-        self.options.prefix.join("cratesfyi.lock")
+        self.config.prefix.join("cratesfyi.lock")
     }
 
     /// Creates a lock file. Daemon will check this lock file and stop operating if its exists.
@@ -64,9 +62,4 @@ impl DocBuilder {
     pub fn is_locked(&self) -> bool {
         self.lock_path().exists()
     }
-
-    /// Returns a reference of options
-    pub fn options(&self) -> &DocBuilderOptions {
-        &self.options
-    }
 }

src/docbuilder/options.rs

@@ -64,6 +64,7 @@ pub struct RustwideBuilder {
     storage: Arc<Storage>,
     metrics: Arc<Metrics>,
     rustc_version: String,
+    skip_build_if_exists: bool,
 }
 
 impl RustwideBuilder {
@@ -92,9 +93,14 @@ impl RustwideBuilder {
             storage,
             metrics,
             rustc_version: String::new(),
+            skip_build_if_exists: false,
         })
     }
 
+    pub fn set_skip_build_if_exists(&mut self, should: bool) {
+        self.skip_build_if_exists = should;
+    }
+
     fn prepare_sandbox(&self, limits: &Limits) -> SandboxBuilder {
         SandboxBuilder::new()
             .cpu_limit(self.config.build_cpu_limit.map(|limit| limit as f32))
@@ -252,7 +258,7 @@ impl RustwideBuilder {
 
     pub fn build_world(&mut self, doc_builder: &mut DocBuilder) -> Result<()> {
         crates_from_path(
-            &doc_builder.options().registry_index_path.clone(),
+            &self.config.registry_index_path.clone(),
             &mut |name, version| {
                 if let Err(err) = self.build_package(doc_builder, name, version, None) {
                     warn!("failed to build package {} {}: {}", name, version, err);
@@ -284,7 +290,7 @@ impl RustwideBuilder {
     ) -> Result<bool> {
         let mut conn = self.db.get()?;
 
-        if !self.should_build(&mut conn, &doc_builder, name, version)? {
+        if !self.should_build(&mut conn, name, version)? {
             return Ok(false);
         }
 
@@ -634,14 +640,8 @@ impl RustwideBuilder {
         .map(|t| t.1)
     }
 
-    fn should_build(
-        &self,
-        conn: &mut Client,
-        docbuilder: &DocBuilder,
-        name: &str,
-        version: &str,
-    ) -> Result<bool> {
-        if docbuilder.options().skip_if_exists {
+    fn should_build(&self, conn: &mut Client, name: &str, version: &str) -> Result<bool> {
+        if self.skip_build_if_exists {
             // Check whether no successful builds are present in the database.
             Ok(conn
                 .query(

src/docbuilder/rustwide_builder.rs

@@ -5,7 +5,6 @@
 pub use self::build_queue::BuildQueue;
 pub use self::config::Config;
 pub use self::context::Context;
-pub use self::docbuilder::options::DocBuilderOptions;
 pub use self::docbuilder::DocBuilder;
 pub use self::docbuilder::RustwideBuilder;
 pub use self::metrics::Metrics;

src/lib.rs

@@ -4,15 +4,15 @@
 
 use crate::{
     utils::{queue_builder, update_release_activity, GithubUpdater},
-    Context, DocBuilder, DocBuilderOptions,
+    Context, DocBuilder,
 };
 use chrono::{Timelike, Utc};
 use failure::Error;
 use log::{debug, error, info};
 use std::thread;
 use std::time::{Duration, Instant};
 
-fn start_registry_watcher(opts: DocBuilderOptions, context: &dyn Context) -> Result<(), Error> {
+fn start_registry_watcher(context: &dyn Context) -> Result<(), Error> {
     let pool = context.pool()?;
     let build_queue = context.build_queue()?;
     let config = context.config()?;
@@ -26,7 +26,7 @@ fn start_registry_watcher(opts: DocBuilderOptions, context: &dyn Context) -> Res
             let mut last_gc = Instant::now();
             loop {
                 let mut doc_builder =
-                    DocBuilder::new(opts.clone(), pool.clone(), build_queue.clone());
+                    DocBuilder::new(config.clone(), pool.clone(), build_queue.clone());
 
                 if doc_builder.is_locked() {
                     debug!("Lock file exists, skipping checking new crates");
@@ -51,14 +51,10 @@ fn start_registry_watcher(opts: DocBuilderOptions, context: &dyn Context) -> Res
 
 pub fn start_daemon(context: &dyn Context, enable_registry_watcher: bool) -> Result<(), Error> {
     let config = context.config()?;
-    let dbopts = DocBuilderOptions::new(config.prefix.clone(), config.registry_index_path.clone());
-
-    // check paths once
-    dbopts.check_paths().unwrap();
 
     if enable_registry_watcher {
         // check new crates every minute
-        start_registry_watcher(dbopts.clone(), context)?;
+        start_registry_watcher(context)?;
     }
 
     // build new crates every minute
@@ -70,8 +66,17 @@ pub fn start_daemon(context: &dyn Context, enable_registry_watcher: bool) -> Res
     thread::Builder::new()
         .name("build queue reader".to_string())
         .spawn(move || {
-            let doc_builder = DocBuilder::new(dbopts.clone(), pool.clone(), build_queue.clone());
-            queue_builder(doc_builder, cloned_config, pool, build_queue, metrics, storage).unwrap();
+            let doc_builder =
+                DocBuilder::new(cloned_config.clone(), pool.clone(), build_queue.clone());
+            queue_builder(
+                doc_builder,
+                cloned_config,
+                pool,
+                build_queue,
+                metrics,
+                storage,
+            )
+            .unwrap();
         })
         .unwrap();