config/Base: Remove unused uploader field

Author: Turbo87

src/config/base.rs

@@ -1,18 +1,11 @@
 //! Base configuration options
 //!
 //! - `HEROKU`: Is this instance of crates_io:: currently running on Heroku.
-//! - `S3_BUCKET`: The S3 bucket used to store crate files. If not present during development,
-//!    crates_io:: will fall back to a local uploader.
-//! - `S3_REGION`: The region in which the bucket was created. Optional if US standard.
-//! - `AWS_ACCESS_KEY`: The access key to interact with S3.
-//! - `AWS_SECRET_KEY`: The secret key to interact with S3.
-//! - `S3_CDN`: Optional CDN configuration for building public facing URLs.
 
-use crate::{env, uploaders::Uploader, Env};
+use crate::Env;
 
 pub struct Base {
     pub env: Env,
-    pub uploader: Uploader,
 }
 
 impl Base {
@@ -22,82 +15,6 @@ impl Base {
             _ => Env::Development,
         };
 
-        let uploader = if env == Env::Production {
-            // `env` panics if these vars are not set, and in production for a primary instance,
-            // that's what we want since we don't want to be able to start the server if the
-            // server doesn't know where to upload crates.
-            Self::s3_panic_if_missing_keys()
-        } else if dotenvy::var("S3_BUCKET").is_ok() {
-            // If we've set the `S3_BUCKET` variable to any value, use all of the values
-            // for the related S3 environment variables and configure the app to upload to
-            // and read from S3 like production does. All values except for bucket are
-            // optional, like production read-only mirrors.
-            info!("Using S3 uploader");
-            Self::s3_maybe_read_only()
-        } else {
-            // If we don't set the `S3_BUCKET` variable, we'll use a development-only
-            // uploader that makes it possible to run and publish to a locally-running
-            // crates.io instance without needing to set up an account and a bucket in S3.
-            info!("Using local uploader, crate files will be in the local_uploads directory");
-            Uploader::Local
-        };
-
-        Self { env, uploader }
-    }
-
-    pub fn uploader(&self) -> &Uploader {
-        &self.uploader
-    }
-
-    fn s3_panic_if_missing_keys() -> Uploader {
-        let index_bucket = match dotenvy::var("S3_INDEX_BUCKET") {
-            Ok(name) => Some(Box::new(s3::Bucket::new(
-                name,
-                dotenvy::var("S3_INDEX_REGION")
-                    .map_or_else(|_err| s3::Region::Default, s3::Region::Region),
-                env("AWS_ACCESS_KEY"),
-                env("AWS_SECRET_KEY"),
-                "https",
-            ))),
-            Err(_) => None,
-        };
-        Uploader::S3 {
-            bucket: Box::new(s3::Bucket::new(
-                env("S3_BUCKET"),
-                dotenvy::var("S3_REGION")
-                    .map_or_else(|_err| s3::Region::Default, s3::Region::Region),
-                env("AWS_ACCESS_KEY"),
-                env("AWS_SECRET_KEY"),
-                "https",
-            )),
-            index_bucket,
-            cdn: dotenvy::var("S3_CDN").ok(),
-        }
-    }
-
-    fn s3_maybe_read_only() -> Uploader {
-        let index_bucket = match dotenvy::var("S3_INDEX_BUCKET") {
-            Ok(name) => Some(Box::new(s3::Bucket::new(
-                name,
-                dotenvy::var("S3_INDEX_REGION")
-                    .map_or_else(|_err| s3::Region::Default, s3::Region::Region),
-                dotenvy::var("AWS_ACCESS_KEY").unwrap_or_default(),
-                dotenvy::var("AWS_SECRET_KEY").unwrap_or_default(),
-                "https",
-            ))),
-            Err(_) => None,
-        };
-        Uploader::S3 {
-            bucket: Box::new(s3::Bucket::new(
-                env("S3_BUCKET"),
-                dotenvy::var("S3_REGION")
-                    .map_or_else(|_err| s3::Region::Default, s3::Region::Region),
-                dotenvy::var("AWS_ACCESS_KEY").unwrap_or_default(),
-                dotenvy::var("AWS_SECRET_KEY").unwrap_or_default(),
-                "https",
-            )),
-            index_bucket,
-            cdn: dotenvy::var("S3_CDN").ok(),
-        }
+        Self { env }
     }
 }

src/config/server.rs

@@ -3,7 +3,7 @@ use ipnetwork::IpNetwork;
 use oauth2::{ClientId, ClientSecret};
 
 use crate::publish_rate_limit::PublishRateLimit;
-use crate::{env, env_optional, uploaders::Uploader, Env};
+use crate::{env, env_optional, Env};
 
 use super::base::Base;
 use super::database_pools::DatabasePools;
@@ -196,10 +196,6 @@ impl Server {
     pub fn env(&self) -> Env {
         self.base.env
     }
-
-    pub fn uploader(&self) -> &Uploader {
-        self.base.uploader()
-    }
 }
 
 pub(crate) fn domain_name() -> String {

src/tests/util/test_app.rs

@@ -3,7 +3,7 @@ use crate::record;
 use crate::util::{chaosproxy::ChaosProxy, fresh_schema::FreshSchema};
 use crates_io::config::{self, BalanceCapacityConfig, Base, DatabasePools, DbPoolConfig};
 use crates_io::storage::StorageConfig;
-use crates_io::{background_jobs::Environment, env, App, Emails, Env, Uploader};
+use crates_io::{background_jobs::Environment, env, App, Emails, Env};
 use crates_io_index::testing::UpstreamIndex;
 use crates_io_index::{Credentials, Repository as WorkerRepository, RepositoryConfig};
 use std::{rc::Rc, sync::Arc, time::Duration};
@@ -355,32 +355,7 @@ impl TestAppBuilder {
 }
 
 fn simple_config() -> config::Server {
-    let uploader = Uploader::S3 {
-        bucket: Box::new(s3::Bucket::new(
-            dotenvy::var("TEST_S3_BUCKET").unwrap_or_else(|_err| "crates-test".into()),
-            parse_test_region(dotenvy::var("TEST_S3_REGION").ok()),
-            dotenvy::var("TEST_AWS_ACCESS_KEY").unwrap_or_default(),
-            dotenvy::var("TEST_AWS_SECRET_KEY").unwrap_or_default(),
-            // When testing we route all API traffic over HTTP so we can
-            // sniff/record it, but everywhere else we use https
-            "http",
-        )),
-        index_bucket: Some(Box::new(s3::Bucket::new(
-            dotenvy::var("TEST_S3_INDEX_BUCKET").unwrap_or_else(|_err| "crates-index-test".into()),
-            parse_test_region(dotenvy::var("TEST_S3_INDEX_REGION").ok()),
-            dotenvy::var("TEST_AWS_ACCESS_KEY").unwrap_or_default(),
-            dotenvy::var("TEST_AWS_SECRET_KEY").unwrap_or_default(),
-            // When testing we route all API traffic over HTTP so we can
-            // sniff/record it, but everywhere else we use https
-            "http",
-        ))),
-        cdn: None,
-    };
-
-    let base = Base {
-        env: Env::Test,
-        uploader,
-    };
+    let base = Base { env: Env::Test };
 
     let db = DatabasePools {
         primary: DbPoolConfig {