From 02c9d9cb76bd4f782aa04945f94019ee5a570e66 Mon Sep 17 00:00:00 2001 From: Satyam Singh Date: Tue, 3 Jan 2023 14:25:13 +0530 Subject: [PATCH] Print Deployment ID in banner --- server/src/banner.rs | 19 +++++++------- server/src/main.rs | 7 +++-- server/src/storage.rs | 38 ++++++++++++---------------- server/src/storage/store_metadata.rs | 14 +++++----- 4 files changed, 36 insertions(+), 42 deletions(-) diff --git a/server/src/banner.rs b/server/src/banner.rs index de6db3f22..2091c44bb 100644 --- a/server/src/banner.rs +++ b/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; } }; diff --git a/server/src/main.rs b/server/src/main.rs index 494d0df65..652f018c6 100644 --- a/server/src/main.rs +++ b/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(); diff --git a/server/src/storage.rs b/server/src/storage.rs index 1dcd84a05..6f40d331a 100644 --- a/server/src/storage.rs +++ b/server/src/storage.rs @@ -123,32 +123,28 @@ impl ObjectStoreFormat { } } -pub async fn resolve_parseable_metadata() -> Result<(), ObjectStorageError> { +pub async fn resolve_parseable_metadata() -> Result { 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 = 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())?; @@ -156,21 +152,19 @@ pub async fn resolve_parseable_metadata() -> Result<(), ObjectStorageError> { 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 = err.into(); - Err(ObjectStorageError::UnhandledError(err)) - } else { - Ok(()) - } + ObjectStorageError::UnhandledError(err) + }) } async fn create_remote_metadata(metadata: &StorageMetadata) -> Result<(), ObjectStorageError> { diff --git a/server/src/storage/store_metadata.rs b/server/src/storage/store_metadata.rs index ec3dd3822..b7725f328 100644 --- a/server/src/storage/store_metadata.rs +++ b/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, + remote_metadata: Option, ) -> 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, }