Print deployment id in banner (#239)

Author: trueleo

server/src/banner.rs

@@ -19,13 +19,13 @@
 
 use crossterm::style::Stylize;
 
-use crate::option::Config;
+use crate::{option::Config, storage::StorageMetadata};
 
-pub fn print(config: &Config) {
+pub fn print(config: &Config, meta: StorageMetadata) {
     let scheme = config.parseable.get_scheme();
     status_info(config, &scheme);
     storage_info(config);
-    version::print();
+    version::print(meta.deployment_id);
     println!();
 }
 
@@ -79,7 +79,7 @@ pub mod version {
     use crossterm::style::Stylize;
     use std::fmt;
 
-    use crate::utils::update;
+    use crate::utils::{uid::Uid, update};
 
     pub enum ParseableVersion {
         Version(semver::Version),
@@ -95,32 +95,33 @@ pub mod version {
         }
     }
 
-    pub fn print_version(current_version: semver::Version, commit_hash: String) {
+    pub fn print_version(current_version: semver::Version, commit_hash: String, id: Uid) {
         eprint!(
             "
     {}
+        Deployment ID:  {}    
         Version:        {}
         Commit hash:    {}
         GitHub:         https://github.com/parseablehq/parseable
         Docs:           https://www.parseable.io/docs/introduction",
             "About:".to_string().blue().bold(),
+            id.to_string(),
             current_version,
             commit_hash
         );
     }
 
-    pub fn print() {
+    pub fn print(id: Uid) {
         // print current version
         let current = current();
 
         match current.0 {
             ParseableVersion::Version(current_version) => {
-                print_version(current_version.clone(), current.1);
+                print_version(current_version.clone(), current.1, id);
                 // check for latest release, if it cannot be fetched then print error as warn and return
                 let latest_release = match update::get_latest() {
                     Ok(latest_release) => latest_release,
-                    Err(e) => {
-                        log::warn!("{}", e);
+                    Err(_) => {
                         return;
                     }
                 };

server/src/main.rs

@@ -54,8 +54,6 @@ mod validator;
 
 use option::CONFIG;
 
-use crate::storage::resolve_parseable_metadata;
-
 // Global configurations
 const MAX_EVENT_PAYLOAD_SIZE: usize = 1024000;
 const API_BASE_PATH: &str = "/api";
@@ -64,14 +62,15 @@ const API_VERSION: &str = "v1";
 #[actix_web::main]
 async fn main() -> anyhow::Result<()> {
     env_logger::init();
-    banner::print(&CONFIG);
     CONFIG.validate();
     let storage = CONFIG.storage().get_object_store();
     CONFIG.validate_storage(&*storage).await;
+    let metadata = storage::resolve_parseable_metadata().await?;
+    banner::print(&CONFIG, metadata);
+
     if let Err(e) = metadata::STREAM_INFO.load(&*storage).await {
         warn!("could not populate local metadata. {:?}", e);
     }
-    resolve_parseable_metadata().await?;
     // track all parquet files already in the data directory
     storage::CACHED_FILES.track_parquet();
 

server/src/storage.rs

@@ -123,54 +123,48 @@ impl ObjectStoreFormat {
     }
 }
 
-pub async fn resolve_parseable_metadata() -> Result<(), ObjectStorageError> {
+pub async fn resolve_parseable_metadata() -> Result<StorageMetadata, ObjectStorageError> {
     let staging_metadata = store_metadata::get_staging_metadata()?;
     let storage = CONFIG.storage().get_object_store();
     let remote_metadata = storage.get_metadata().await?;
 
-    let check = store_metadata::check_metadata_conflict(
-        staging_metadata.as_ref(),
-        remote_metadata.as_ref(),
-    );
+    let check = store_metadata::check_metadata_conflict(staging_metadata, remote_metadata);
 
     const MISMATCH: &str = "Could not start the server because metadata file found in staging directory does not match one in the storage";
-    let err: Option<&str> = match check {
-        EnvChange::None => None,
-        EnvChange::StagingMismatch => Some(MISMATCH),
-        EnvChange::StorageMismatch => Some(MISMATCH),
+    let res: Result<StorageMetadata, &str> = match check {
+        EnvChange::None(metadata) => Ok(metadata),
+        EnvChange::StagingMismatch => Err(MISMATCH),
+        EnvChange::StorageMismatch => Err(MISMATCH),
         EnvChange::NewRemote => {
-            Some("Could not start the server because metadata not found in storage")
+            Err("Could not start the server because metadata not found in storage")
         }
-        EnvChange::NewStaging => {
+        EnvChange::NewStaging(mut metadata) => {
             create_dir_all(CONFIG.staging_dir())?;
-            let mut remote_meta = remote_metadata.expect("remote metadata exists");
-            remote_meta.staging = CONFIG.staging_dir().canonicalize()?;
-            create_remote_metadata(&remote_meta).await?;
-            put_staging_metadata(&remote_meta)?;
+            metadata.staging = CONFIG.staging_dir().canonicalize()?;
+            create_remote_metadata(&metadata).await?;
+            put_staging_metadata(&metadata)?;
 
-            None
+            Ok(metadata)
         }
         EnvChange::CreateBoth => {
             create_dir_all(CONFIG.staging_dir())?;
             let metadata = StorageMetadata::new();
             create_remote_metadata(&metadata).await?;
             put_staging_metadata(&metadata)?;
 
-            None
+            Ok(metadata)
         }
     };
 
-    if let Some(err) = err {
+    res.map_err(|err| {
         let err = format!(
             "{}. {}",
             err,
             "Join us on Parseable Slack to report this incident : https://launchpass.com/parseable"
         );
         let err: Box<dyn std::error::Error + Send + Sync + 'static> = err.into();
-        Err(ObjectStorageError::UnhandledError(err))
-    } else {
-        Ok(())
-    }
+        ObjectStorageError::UnhandledError(err)
+    })
 }
 
 async fn create_remote_metadata(metadata: &StorageMetadata) -> Result<(), ObjectStorageError> {

server/src/storage/store_metadata.rs

@@ -62,8 +62,8 @@ impl StorageMetadata {
 }
 
 pub fn check_metadata_conflict(
-    staging_metadata: Option<&StorageMetadata>,
-    remote_metadata: Option<&StorageMetadata>,
+    staging_metadata: Option<StorageMetadata>,
+    remote_metadata: Option<StorageMetadata>,
 ) -> EnvChange {
     match (staging_metadata, remote_metadata) {
         (Some(staging), Some(remote)) if staging.mode == remote.mode => {
@@ -72,23 +72,23 @@ pub fn check_metadata_conflict(
             } else if staging.staging != remote.staging {
                 EnvChange::StagingMismatch
             } else {
-                EnvChange::None
+                EnvChange::None(staging)
             }
         }
         (Some(staging), Some(remote)) if staging.mode != remote.mode => EnvChange::StorageMismatch,
         (None, None) => EnvChange::CreateBoth,
-        (None, Some(_)) => EnvChange::NewStaging,
+        (None, Some(remote)) => EnvChange::NewStaging(remote),
         (Some(_), None) => EnvChange::NewRemote,
         _ => unreachable!(),
     }
 }
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum EnvChange {
-    None,
+    None(StorageMetadata),
     StagingMismatch,
     StorageMismatch,
     NewRemote,
-    NewStaging,
+    NewStaging(StorageMetadata),
     CreateBoth,
 }