refactor: Remobe file from file uploaders modules

Author: sfauvel

mithril-aggregator/src/artifact_builder/cardano_immutable_files_full.rs

@@ -173,7 +173,7 @@ mod tests {
     use mithril_common::{entities::CompressionAlgorithm, test_utils::fake_data};
 
     use crate::{
-        file_uploaders::MockFileUploader, test_tools::TestLogger, DumbFileUploader, DumbSnapshotter,
+        file_uploaders::MockFileUploader, test_tools::TestLogger, DumbUploader, DumbSnapshotter,
     };
 
     use super::*;
@@ -188,7 +188,7 @@ mod tests {
             .unwrap();
 
         let dumb_snapshotter = Arc::new(DumbSnapshotter::new());
-        let dumb_snapshot_uploader = Arc::new(DumbFileUploader::new());
+        let dumb_snapshot_uploader = Arc::new(DumbUploader::new());
 
         let cardano_immutable_files_full_artifact_builder =
             CardanoImmutableFilesFullArtifactBuilder::new(
@@ -235,7 +235,7 @@ mod tests {
                 fake_data::network(),
                 &Version::parse("1.0.0").unwrap(),
                 Arc::new(DumbSnapshotter::new()),
-                Arc::new(DumbFileUploader::new()),
+                Arc::new(DumbUploader::new()),
                 CompressionAlgorithm::default(),
                 TestLogger::stdout(),
             );
@@ -262,7 +262,7 @@ mod tests {
                 network,
                 &Version::parse("1.0.0").unwrap(),
                 Arc::new(DumbSnapshotter::new()),
-                Arc::new(DumbFileUploader::new()),
+                Arc::new(DumbUploader::new()),
                 CompressionAlgorithm::Gzip,
                 TestLogger::stdout(),
             );
@@ -291,7 +291,7 @@ mod tests {
                     fake_data::network(),
                     &Version::parse("1.0.0").unwrap(),
                     Arc::new(DumbSnapshotter::new()),
-                    Arc::new(DumbFileUploader::new()),
+                    Arc::new(DumbUploader::new()),
                     algorithm,
                     TestLogger::stdout(),
                 );

mithril-aggregator/src/dependency_injection/builder.rs

@@ -64,7 +64,7 @@ use crate::{
     },
     entities::AggregatorEpochSettings,
     event_store::{EventMessage, EventStore, TransmitterService},
-    file_uploaders::GcpFileUploader,
+    file_uploaders::GcpUploader,
     http_server::routes::router::{self, RouterConfig, RouterState},
     services::{
         AggregatorSignableSeedBuilder, AggregatorUpkeepService, BufferedCertifierService,
@@ -77,9 +77,9 @@ use crate::{
     store::CertificatePendingStorer,
     tools::{CExplorerSignerRetriever, GenesisToolsDependency, SignersImporter},
     AggregatorConfig, AggregatorRunner, AggregatorRuntime, CompressedArchiveSnapshotter,
-    Configuration, DependencyContainer, DumbFileUploader, DumbSnapshotter, EpochSettingsStorer,
-    FileUploader, LocalFileUploader, MetricsService, MithrilSignerRegisterer, MultiSigner,
-    MultiSignerImpl, RemoteSnapshotUploader, SingleSignatureAuthenticator, SnapshotUploaderType,
+    Configuration, DependencyContainer, DumbSnapshotter, DumbUploader, EpochSettingsStorer,
+    FileUploader, LocalUploader, MetricsService, MithrilSignerRegisterer, MultiSigner,
+    MultiSignerImpl, RemoteUploader, SingleSignatureAuthenticator, SnapshotUploaderType,
     Snapshotter, SnapshotterCompressionAlgorithm, VerificationKeyStorer,
 };
 
@@ -462,23 +462,23 @@ impl DependenciesBuilder {
                             )
                         })?;
 
-                    Ok(Arc::new(RemoteSnapshotUploader::new(
-                        Box::new(GcpFileUploader::new(
+                    Ok(Arc::new(RemoteUploader::new(
+                        Box::new(GcpUploader::new(
                             bucket,
                             self.configuration.snapshot_use_cdn_domain,
                             logger.clone(),
                         )),
                         logger,
                     )))
                 }
-                SnapshotUploaderType::Local => Ok(Arc::new(LocalFileUploader::new(
+                SnapshotUploaderType::Local => Ok(Arc::new(LocalUploader::new(
                     self.configuration.get_server_url(),
                     &self.configuration.snapshot_directory,
                     logger,
                 ))),
             }
         } else {
-            Ok(Arc::new(DumbFileUploader::new()))
+            Ok(Arc::new(DumbUploader::new()))
         }
     }
 

mithril-aggregator/src/file_uploaders/dumb_file_uploader.rs renamed to mithril-aggregator/src/file_uploaders/dumb_uploader.rs

@@ -9,11 +9,11 @@ use super::{FileLocation, FileUploader};
 ///
 /// It actually does NOT upload any file but remembers the last file it
 /// was asked to upload. This is intended to by used by integration tests.
-pub struct DumbFileUploader {
+pub struct DumbUploader {
     last_uploaded: RwLock<Option<String>>,
 }
 
-impl DumbFileUploader {
+impl DumbUploader {
     /// Create a new instance.
     pub fn new() -> Self {
         Self {
@@ -32,14 +32,14 @@ impl DumbFileUploader {
     }
 }
 
-impl Default for DumbFileUploader {
+impl Default for DumbUploader {
     fn default() -> Self {
         Self::new()
     }
 }
 
 #[async_trait]
-impl FileUploader for DumbFileUploader {
+impl FileUploader for DumbUploader {
     /// Upload a file
     async fn upload(&self, filepath: &Path) -> StdResult<FileLocation> {
         let mut value = self
@@ -60,7 +60,7 @@ mod tests {
 
     #[tokio::test]
     async fn test_dumb_uploader() {
-        let uploader = DumbFileUploader::new();
+        let uploader = DumbUploader::new();
         assert!(uploader
             .get_last_upload()
             .expect("uploader should not fail")

mithril-aggregator/src/file_uploaders/gcp_file_uploader.rs renamed to mithril-aggregator/src/file_uploaders/gcp_uploader.rs

@@ -14,15 +14,15 @@ use mithril_common::StdResult;
 use crate::file_uploaders::FileLocation;
 use crate::FileUploader;
 
-/// GcpFileUploader represents a Google Cloud Platform file uploader interactor
-pub struct GcpFileUploader {
+/// GcpUploader represents a Google Cloud Platform file uploader interactor
+pub struct GcpUploader {
     bucket: String,
     use_cdn_domain: bool,
     logger: Logger,
 }
 
-impl GcpFileUploader {
-    /// GcpFileUploader factory
+impl GcpUploader {
+    /// GcpUploader factory
     pub fn new(bucket: String, use_cdn_domain: bool, logger: Logger) -> Self {
         Self {
             bucket,
@@ -44,7 +44,7 @@ impl GcpFileUploader {
 }
 
 #[async_trait]
-impl FileUploader for GcpFileUploader {
+impl FileUploader for GcpUploader {
     async fn upload(&self, filepath: &Path) -> StdResult<FileLocation> {
         if env::var("GOOGLE_APPLICATION_CREDENTIALS_JSON").is_err() {
             return Err(anyhow!(
@@ -107,7 +107,7 @@ mod tests {
     async fn get_location_not_using_cdn_domain_return_google_api_uri() {
         let use_cdn_domain = false;
 
-        let file_uploader = GcpFileUploader::new(
+        let file_uploader = GcpUploader::new(
             "cardano-testnet".to_string(),
             use_cdn_domain,
             TestLogger::stdout(),
@@ -125,7 +125,7 @@ mod tests {
     async fn get_location_using_cdn_domain_return_cdn_in_uri() {
         let use_cdn_domain = true;
 
-        let file_uploader = GcpFileUploader::new(
+        let file_uploader = GcpUploader::new(
             "cdn.mithril.network".to_string(),
             use_cdn_domain,
             TestLogger::stdout(),

mithril-aggregator/src/file_uploaders/file_uploader.rs renamed to mithril-aggregator/src/file_uploaders/interface.rs

@@ -10,8 +10,8 @@ use crate::file_uploaders::{FileLocation, FileUploader};
 use crate::http_server;
 use crate::tools;
 
-/// LocalFileUploader is a file uploader working using local files
-pub struct LocalFileUploader {
+/// LocalUploader is a file uploader working using local files
+pub struct LocalUploader {
     /// File server listening IP
     file_server_url: String,
 
@@ -21,11 +21,11 @@ pub struct LocalFileUploader {
     logger: Logger,
 }
 
-impl LocalFileUploader {
-    /// LocalFileUploader factory
+impl LocalUploader {
+    /// LocalUploader factory
     pub(crate) fn new(file_server_url: String, target_location: &Path, logger: Logger) -> Self {
         let logger = logger.new_with_component_name::<Self>();
-        debug!(logger, "New LocalFileUploader created"; "file_server_url" => &file_server_url);
+        debug!(logger, "New LocalUploader created"; "file_server_url" => &file_server_url);
         Self {
             file_server_url,
             target_location: target_location.to_path_buf(),
@@ -35,7 +35,7 @@ impl LocalFileUploader {
 }
 
 #[async_trait]
-impl FileUploader for LocalFileUploader {
+impl FileUploader for LocalUploader {
     async fn upload(&self, filepath: &Path) -> StdResult<FileLocation> {
         let archive_name = filepath.file_name().unwrap().to_str().unwrap();
         let target_path = &self.target_location.join(archive_name);
@@ -69,7 +69,7 @@ mod tests {
     use crate::http_server;
     use crate::test_tools::TestLogger;
 
-    use super::LocalFileUploader;
+    use super::LocalUploader;
 
     fn create_fake_archive(dir: &Path, digest: &str) -> PathBuf {
         let file_path = dir.join(format!("test.{digest}.tar.gz"));
@@ -96,7 +96,7 @@ mod tests {
             http_server::SERVER_BASE_PATH,
             &digest
         );
-        let uploader = LocalFileUploader::new(url, target_dir.path(), TestLogger::stdout());
+        let uploader = LocalUploader::new(url, target_dir.path(), TestLogger::stdout());
 
         let location = uploader
             .upload(&archive)
@@ -112,7 +112,7 @@ mod tests {
         let target_dir = tempdir().unwrap();
         let digest = "41e27b9ed5a32531b95b2b7ff3c0757591a06a337efaf19a524a998e348028e7";
         let archive = create_fake_archive(source_dir.path(), digest);
-        let uploader = LocalFileUploader::new(
+        let uploader = LocalUploader::new(
             "http://test.com:8080/".to_string(),
             target_dir.path(),
             TestLogger::stdout(),

mithril-aggregator/src/file_uploaders/local_file_uploader.rs renamed to mithril-aggregator/src/file_uploaders/local_uploader.rs

@@ -1,15 +1,15 @@
-mod dumb_file_uploader;
-mod file_uploader;
-mod gcp_file_uploader;
-mod local_file_uploader;
-mod remote_file_uploader;
+mod dumb_uploader;
+mod gcp_uploader;
+mod interface;
+mod local_uploader;
+mod remote_uploader;
 
-pub use dumb_file_uploader::*;
-pub use file_uploader::FileLocation;
-pub use file_uploader::FileUploader;
-pub use gcp_file_uploader::GcpFileUploader;
-pub use local_file_uploader::LocalFileUploader;
-pub use remote_file_uploader::RemoteSnapshotUploader;
+pub use dumb_uploader::*;
+pub use gcp_uploader::GcpUploader;
+pub use interface::FileLocation;
+pub use interface::FileUploader;
+pub use local_uploader::LocalUploader;
+pub use remote_uploader::RemoteUploader;
 
 #[cfg(test)]
-pub use file_uploader::MockFileUploader;
+pub use interface::MockFileUploader;

mithril-aggregator/src/file_uploaders/mod.rs

@@ -7,17 +7,17 @@ use mithril_common::StdResult;
 
 use crate::file_uploaders::{FileLocation, FileUploader};
 
-/// RemoteSnapshotUploader is a snapshot uploader working using Google Cloud Platform services
-pub struct RemoteSnapshotUploader {
+/// RemoteUploader is a snapshot uploader working using Google Cloud Platform services
+pub struct RemoteUploader {
     file_uploader: Box<dyn FileUploader>,
     logger: Logger,
 }
 
-impl RemoteSnapshotUploader {
-    /// RemoteSnapshotUploader factory
+impl RemoteUploader {
+    /// RemoteUploader factory
     pub fn new(file_uploader: Box<dyn FileUploader>, logger: Logger) -> Self {
         let logger = logger.new_with_component_name::<Self>();
-        debug!(logger, "New RemoteSnapshotUploader created");
+        debug!(logger, "New RemoteUploader created");
         Self {
             file_uploader,
             logger,
@@ -26,7 +26,7 @@ impl RemoteSnapshotUploader {
 }
 
 #[async_trait]
-impl FileUploader for RemoteSnapshotUploader {
+impl FileUploader for RemoteUploader {
     async fn upload(&self, snapshot_filepath: &Path) -> StdResult<FileLocation> {
         let location = self.file_uploader.upload(snapshot_filepath).await?;
         debug!(self.logger, "Snapshot upload to remote storage completed"; "location" => &location);
@@ -44,7 +44,7 @@ mod tests {
     use crate::file_uploaders::{FileUploader, MockFileUploader};
     use crate::test_tools::TestLogger;
 
-    use super::RemoteSnapshotUploader;
+    use super::RemoteUploader;
 
     #[tokio::test]
     async fn upload_call_uploader_and_return_location() {
@@ -54,8 +54,7 @@ mod tests {
             .with(eq(Path::new("test/snapshot.xxx.tar.gz")))
             .times(1)
             .returning(|_| Ok("https://cdn.mithril.network/snapshot.xxx.tar.gz".to_string()));
-        let snapshot_uploader =
-            RemoteSnapshotUploader::new(Box::new(file_uploader), TestLogger::stdout());
+        let snapshot_uploader = RemoteUploader::new(Box::new(file_uploader), TestLogger::stdout());
         let filepath = Path::new("test/snapshot.xxx.tar.gz");
         let expected_location = "https://cdn.mithril.network/snapshot.xxx.tar.gz".to_string();
 
@@ -73,8 +72,7 @@ mod tests {
         file_uploader
             .expect_upload()
             .returning(|_| Err(anyhow!("unexpected error")));
-        let snapshot_uploader =
-            RemoteSnapshotUploader::new(Box::new(file_uploader), TestLogger::stdout());
+        let snapshot_uploader = RemoteUploader::new(Box::new(file_uploader), TestLogger::stdout());
         let snapshot_filepath = Path::new("test/snapshot.xxx.tar.gz");
 
         let result = snapshot_uploader

mithril-aggregator/src/file_uploaders/remote_file_uploader.rs renamed to mithril-aggregator/src/file_uploaders/remote_uploader.rs

@@ -38,9 +38,7 @@ pub use crate::configuration::{
 pub use crate::multi_signer::{MultiSigner, MultiSignerImpl};
 pub use commands::{CommandType, MainOpts};
 pub use dependency_injection::DependencyContainer;
-pub use file_uploaders::{
-    DumbFileUploader, FileUploader, LocalFileUploader, RemoteSnapshotUploader,
-};
+pub use file_uploaders::{DumbUploader, FileUploader, LocalUploader, RemoteUploader};
 pub use message_adapters::{FromRegisterSignerAdapter, ToCertificatePendingMessageAdapter};
 pub use metrics::*;
 pub use runtime::{

mithril-aggregator/src/lib.rs

@@ -7,7 +7,7 @@ use mithril_aggregator::{
     database::{record::SignedEntityRecord, repository::OpenMessageRepository},
     dependency_injection::DependenciesBuilder,
     event_store::EventMessage,
-    AggregatorRuntime, Configuration, DependencyContainer, DumbFileUploader, DumbSnapshotter,
+    AggregatorRuntime, Configuration, DependencyContainer, DumbSnapshotter, DumbUploader,
     SignerRegistrationError,
 };
 use mithril_common::{
@@ -100,7 +100,7 @@ macro_rules! assert_metrics_eq {
 
 pub struct RuntimeTester {
     pub network: String,
-    pub snapshot_uploader: Arc<DumbFileUploader>,
+    pub snapshot_uploader: Arc<DumbUploader>,
     pub chain_observer: Arc<FakeObserver>,
     pub immutable_file_observer: Arc<DumbImmutableFileObserver>,
     pub digester: Arc<DumbImmutableDigester>,
@@ -130,7 +130,7 @@ impl RuntimeTester {
         let logger = build_logger();
         let global_logger = slog_scope::set_global_logger(logger.clone());
         let network = configuration.network.clone();
-        let snapshot_uploader = Arc::new(DumbFileUploader::new());
+        let snapshot_uploader = Arc::new(DumbUploader::new());
         let immutable_file_observer = Arc::new(DumbImmutableFileObserver::new());
         immutable_file_observer
             .shall_return(Some(start_time_point.immutable_file_number))