replace some arcs with ref

Author: syphar

src/bin/cratesfyi.rs

@@ -205,24 +205,17 @@ impl CommandLine {
 
                 start_background_metrics_webserver(Some(metric_server_socket_addr), &ctx)?;
 
-                ctx.runtime.block_on(async {
-                    docs_rs::utils::watch_registry(
-                        ctx.async_build_queue.clone(),
-                        ctx.config.clone(),
-                        ctx.index.clone(),
-                    )
-                    .await
+                ctx.runtime.block_on(async move {
+                    docs_rs::utils::watch_registry(&ctx.async_build_queue, &ctx.config, ctx.index)
+                        .await
                 })?;
             }
             Self::StartBuildServer {
                 metric_server_socket_addr,
             } => {
                 start_background_metrics_webserver(Some(metric_server_socket_addr), &ctx)?;
 
-                let build_queue = ctx.build_queue.clone();
-                let config = ctx.config.clone();
-                let rustwide_builder = RustwideBuilder::init(&ctx)?;
-                queue_builder(&ctx, rustwide_builder, build_queue, config)?;
+                queue_builder(&ctx, RustwideBuilder::init(&ctx)?)?;
             }
             Self::StartWebServer { socket_addr } => {
                 // Blocks indefinitely
@@ -654,14 +647,8 @@ impl DatabaseSubcommand {
                 .runtime
                 .block_on(async move {
                     let mut conn = ctx.pool.get_async().await?;
-                    db::delete_version(
-                        &mut conn,
-                        &ctx.async_storage,
-                        &ctx.config,
-                        &name,
-                        &version,
-                    )
-                    .await
+                    db::delete_version(&mut conn, &ctx.async_storage, &ctx.config, &name, &version)
+                        .await
                 })
                 .context("failed to delete the version")?,
             Self::Delete {

src/cdn.rs

@@ -51,7 +51,7 @@ pub enum CdnBackend {
 }
 
 impl CdnBackend {
-    pub async fn new(config: &Arc<Config>) -> CdnBackend {
+    pub async fn new(config: &Config) -> CdnBackend {
         match config.cdn_backend {
             CdnKind::CloudFront => {
                 let shared_config = aws_config::load_defaults(BehaviorVersion::latest()).await;

src/storage/mod.rs

@@ -187,7 +187,6 @@ impl AsyncStorage {
         config: Arc<Config>,
     ) -> Result<Self> {
         Ok(Self {
-            config: config.clone(),
             backend: match config.storage_backend {
                 StorageKind::Database => {
                     StorageBackend::Database(DatabaseBackend::new(pool, metrics))
@@ -196,6 +195,7 @@ impl AsyncStorage {
                     StorageBackend::S3(Box::new(S3Backend::new(metrics, &config).await?))
                 }
             },
+            config,
         })
     }
 

src/utils/daemon.rs

@@ -19,8 +19,8 @@ use tracing::{debug, info};
 /// NOTE: this should only be run once, otherwise crates would be added
 /// to the queue multiple times.
 pub async fn watch_registry(
-    build_queue: Arc<AsyncBuildQueue>,
-    config: Arc<Config>,
+    build_queue: &AsyncBuildQueue,
+    config: &Config,
     index: Arc<Index>,
 ) -> Result<(), Error> {
     let mut last_gc = Instant::now();
@@ -56,13 +56,12 @@ fn start_registry_watcher(context: &Context) -> Result<(), Error> {
     let build_queue = context.async_build_queue.clone();
     let config = context.config.clone();
     let index = context.index.clone();
-    let runtime = context.runtime.clone();
 
-    runtime.spawn(async {
+    context.runtime.spawn(async move {
         // space this out to prevent it from clashing against the queue-builder thread on launch
         tokio::time::sleep(Duration::from_secs(30)).await;
 
-        watch_registry(build_queue, config, index).await
+        watch_registry(&build_queue, &config, index).await
     });
 
     Ok(())
@@ -195,14 +194,12 @@ pub fn start_daemon(context: Context, enable_registry_watcher: bool) -> Result<(
     }
 
     // build new crates every minute
-    let build_queue = context.build_queue.clone();
-    let config = context.config.clone();
     let rustwide_builder = RustwideBuilder::init(&context)?;
     thread::Builder::new()
         .name("build queue reader".to_string())
         .spawn({
             let context = context.clone();
-            move || queue_builder(&context, rustwide_builder, build_queue, config).unwrap()
+            move || queue_builder(&context, rustwide_builder).unwrap()
         })
         .unwrap();
 

src/utils/queue_builder.rs

@@ -1,26 +1,23 @@
 use crate::Context;
-use crate::{BuildQueue, Config, docbuilder::RustwideBuilder, utils::report_error};
+use crate::{docbuilder::RustwideBuilder, utils::report_error};
 use anyhow::{Context as _, Error};
 use std::panic::{AssertUnwindSafe, catch_unwind};
-use std::sync::Arc;
 use std::time::Duration;
 use std::{fs, io, path::Path, thread};
 use tracing::{debug, error, warn};
 
-pub fn queue_builder(
-    context: &Context,
-    mut builder: RustwideBuilder,
-    build_queue: Arc<BuildQueue>,
-    config: Arc<Config>,
-) -> Result<(), Error> {
+pub fn queue_builder(context: &Context, mut builder: RustwideBuilder) -> Result<(), Error> {
     loop {
-        if let Err(e) = remove_tempdirs(&config.temp_dir) {
+        let temp_dir = &context.config.temp_dir;
+        if let Err(e) = remove_tempdirs(temp_dir) {
             report_error(&anyhow::anyhow!(e).context(format!(
                 "failed to clean temporary directory {:?}",
-                &config.temp_dir
+                temp_dir
             )));
         }
 
+        let build_queue = &context.build_queue;
+
         // check lock file
         match build_queue.is_locked().context("could not get queue lock") {
             Ok(true) => {