Issue-3479: Refactor: Fetch Platform Version

Cargo.toml

@@ -15,6 +15,7 @@ members = [
     "crates/fluvio-cli",
     "crates/fluvio-cli-common",
     "crates/fluvio-cluster",
+    "crates/fluvio-common",
     "crates/fluvio-compression",
     "crates/fluvio-controlplane",
     "crates/fluvio-controlplane-metadata",
@@ -153,6 +154,7 @@ fluvio = { version = "0.21.0", path = "crates/fluvio" }
 fluvio-auth = { path = "crates/fluvio-auth" }
 fluvio-channel = { path = "crates/fluvio-channel" }
 fluvio-cli-common = { path = "crates/fluvio-cli-common"}
+fluvio-common = { path = "crates/fluvio-common" }
 fluvio-compression = { version = "0.3", path = "crates/fluvio-compression" }
 fluvio-connector-package = { path = "crates/fluvio-connector-package/" }
 fluvio-controlplane = { path = "crates/fluvio-controlplane" }

crates/fluvio-cli/Cargo.toml

@@ -89,6 +89,7 @@ fluvio-package-index = { workspace = true }
 fluvio-extension-common = { workspace = true,  features = ["target"] }
 fluvio-channel = { workspace = true }
 fluvio-cli-common = { workspace = true  }
+fluvio-common = { workspace = true }
 fluvio-hub-util = { workspace = true  }
 fluvio-smartengine = { workspace = true,  features = ["transformation"]}
 fluvio-protocol = { workspace = true, features=["record","api"] }

crates/fluvio-cli/src/install/update.rs

@@ -277,12 +277,11 @@ pub async fn check_update_available(
     let package = agent.package_from_response(&body).await?;
 
     let release = package.latest_release_for_target(&target, prerelease)?;
-    let latest_version = release.version.clone();
-    let current_version =
-        Version::parse(crate::VERSION).expect("Fluvio CLI 'VERSION' should be a valid semver");
+    let latest_version = &release.version;
+    let current_version = &*crate::FLUVIO_PLATFORM_VERSION;
 
     if current_version < latest_version {
-        Ok(Some(latest_version))
+        Ok(Some(latest_version.clone()))
     } else {
         Ok(None)
     }

crates/fluvio-cli/src/lib.rs

@@ -12,9 +12,8 @@ mod render;
 pub(crate) mod monitoring;
 
 pub(crate) use error::CliError;
+use fluvio_common::FLUVIO_PLATFORM_VERSION;
 use fluvio_extension_common as common;
-pub(crate) const VERSION: &str = include_str!("../../../VERSION");
-
 use fluvio_index::HttpAgent;
 use install::update::{
     should_always_print_available_update, check_update_available, prompt_available_update,
@@ -197,7 +196,7 @@ mod root {
                         println!("Current channel: {}", &channel_name);
                     };
 
-                    let version = semver::Version::parse(crate::VERSION).unwrap();
+                    let version = crate::FLUVIO_PLATFORM_VERSION.clone();
                     cluster.process(out, version, root.target).await?;
                 }
                 Self::Install(mut install) => {

crates/fluvio-cli/src/version.rs

@@ -20,7 +20,7 @@ impl VersionOpt {
             self.print("Release Channel", &channel_name);
         };
 
-        self.print("Fluvio CLI", crate::VERSION.trim());
+        self.print("Fluvio CLI", &crate::FLUVIO_PLATFORM_VERSION.to_string());
         self.print("Fluvio CLI Arch", CURRENT_PLATFORM);
 
         if let Some(sha) = self.format_cli_sha() {

crates/fluvio-cluster/Cargo.toml

@@ -73,6 +73,7 @@ fluvio-future = { workspace = true }
 
 fluvio = { workspace = true  }
 fluvio-extension-common = { workspace = true,  optional = true }
+fluvio-common = { workspace = true }
 fluvio-controlplane-metadata = { workspace = true,  features = ["k8",] }
 fluvio-sc-schema = { workspace = true  }
 fluvio-types = { workspace = true  }

crates/fluvio-cluster/src/cli/mod.rs

@@ -34,8 +34,7 @@ use fluvio_extension_common as common;
 use common::target::ClusterTarget;
 use common::output::Terminal;
 use fluvio_channel::{ImageTagStrategy, FLUVIO_IMAGE_TAG_STRATEGY};
-
-pub(crate) const VERSION: &str = include_str!("../../../../VERSION");
+use fluvio_common::FLUVIO_PLATFORM_VERSION;
 
 /// Manage and view Fluvio clusters
 #[derive(Debug, Parser)]
@@ -104,10 +103,11 @@ impl ClusterCmd {
                         .unwrap_or(ImageTagStrategy::Version);
                     match tag_strategy {
                         ImageTagStrategy::Version => {
-                            debug!("Using image version: {}", VERSION);
+                            debug!("Using image version: {}", *FLUVIO_PLATFORM_VERSION);
                         }
                         ImageTagStrategy::VersionGit => {
-                            let image_version = format!("{}-{}", VERSION, env!("GIT_HASH"));
+                            let image_version =
+                                format!("{}-{}", *FLUVIO_PLATFORM_VERSION, env!("GIT_HASH"));
                             debug!("Using image version: {:?}", &image_version);
                             start.k8_config.image_version = Some(image_version);
                         }
@@ -127,7 +127,8 @@ impl ClusterCmd {
                     match tag_strategy {
                         ImageTagStrategy::Version => {}
                         ImageTagStrategy::VersionGit => {
-                            let image_version = format!("{}-{}", VERSION, env!("GIT_HASH"));
+                            let image_version =
+                                format!("{}-{}", *FLUVIO_PLATFORM_VERSION, env!("GIT_HASH"));
                             upgrade.start.k8_config.image_version = Some(image_version);
                         }
                         ImageTagStrategy::Git => upgrade.start.develop = true,

crates/fluvio-common/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "fluvio-common"
+version = "0.0.0"
+edition = "2021"
+authors = ["Fluvio Contributors <[email protected]>"]
+description = "Fluvio common code"
+repository = "https://github.com/infinyon/fluvio"
+license = "Apache-2.0"
+publish = false
+
+[lib]
+name = "fluvio_common"
+path = "src/lib.rs"
+
+[dependencies]
+once_cell = { workspace = true }
+semver = { workspace = true }

crates/fluvio-common/src/lib.rs

@@ -0,0 +1,7 @@
+use once_cell::sync::Lazy;
+use semver::Version;
+
+pub static FLUVIO_PLATFORM_VERSION: Lazy<Version> = Lazy::new(|| {
+    let version = include_str!("../../../VERSION").trim();
+    Version::parse(version).expect("Fluvio Platform 'VERSION' should be a valid semver.")
+});

crates/fluvio-common/tests/mod.rs

@@ -0,0 +1,6 @@
+#[test]
+fn fluvio_version_is_formatted_correctly() {
+    let current_version = &*fluvio_common::FLUVIO_PLATFORM_VERSION;
+    let minimum_version = &semver::Version::new(0, 0, 0);
+    assert!(current_version > minimum_version);
+}

crates/fluvio-run/Cargo.toml

@@ -24,14 +24,15 @@ spu_smartengine = ["fluvio-spu/smartengine"]
 rustls = ["fluvio-future/rust_tls"]
 
 [dependencies]
-clap = { workspace = true, features = ["std", "derive", "help", "usage", "error-context"]}
+clap = { workspace = true, features = ["std", "derive", "help", "usage", "error-context", "string"]}
 semver = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 
 # regardless of TLS, sc and spu always use openssl_tls for now because we need cert API
+fluvio-common = { workspace = true }
 fluvio-future = { workspace = true, features = ["subscriber"] }
 fluvio-extension-common = { workspace = true }
 fluvio-sc = { path = "../fluvio-sc", default-features = false }

crates/fluvio-run/src/lib.rs

@@ -4,14 +4,13 @@ mod error;
 
 pub use error::RunnerError;
 use error::Result;
+use fluvio_common::FLUVIO_PLATFORM_VERSION;
 use fluvio_spu::SpuOpt;
 use fluvio_sc::cli::ScOpt;
 use fluvio_extension_common::FluvioExtensionMetadata;
 
-const VERSION: &str = include_str!("../../../VERSION");
-
 #[derive(Debug, Parser)]
-#[command(version = crate::VERSION)]
+#[command(version = FLUVIO_PLATFORM_VERSION.to_string())]
 pub enum RunCmd {
     /// Run a new Streaming Processing Unit (SPU)
     #[command(name = "spu")]
@@ -74,7 +73,7 @@ pub struct VersionOpt {}
 impl VersionOpt {
     pub fn process(self) -> Result<()> {
         println!("Git Commit: {}", env!("GIT_HASH"));
-        println!("Platform Version: {VERSION}");
+        println!("Platform Version: {}", *FLUVIO_PLATFORM_VERSION);
 
         Ok(())
     }

crates/fluvio-sc/Cargo.toml

@@ -54,6 +54,7 @@ fluvio-types = { workspace = true,  features = [
 ] }
 fluvio-sc-schema = { workspace = true }
 fluvio-stream-model = { workspace = true  }
+fluvio-common = { workspace = true }
 fluvio-controlplane = { workspace = true  }
 fluvio-controlplane-metadata = { workspace = true, features = ["k8","serde"] }
 fluvio-stream-dispatcher = { workspace = true }
@@ -69,4 +70,4 @@ flv-tls-proxy = { workspace = true }
 rand = { workspace = true }
 fluvio-future = { workspace = true, features = ["fixture"] }
 flv-util = { workspace = true, features = ["fixture"] }
-fluvio-stream-model = { workspace = true, features = ["fixture"] }
+fluvio-stream-model = { workspace = true, features = ["fixture"] }

crates/fluvio-sc/src/lib.rs

@@ -15,7 +15,7 @@ mod controllers;
 #[cfg(feature = "k8")]
 pub use init::start_main_loop;
 
-const VERSION: &str = include_str!("../../../VERSION");
+use fluvio_common::FLUVIO_PLATFORM_VERSION;
 
 pub mod dispatcher {
     pub use fluvio_stream_dispatcher::*;

crates/fluvio-sc/src/services/public_api/api_version.rs

@@ -1,6 +1,5 @@
 use tracing::{trace, instrument, debug};
 use semver::Version;
-use once_cell::sync::Lazy;
 use anyhow::Result;
 
 use fluvio_protocol::api::{RequestMessage, ResponseMessage, Request};
@@ -14,14 +13,12 @@ use fluvio_sc_schema::AdminPublicApiKey;
 
 // Fluvi Client version 0.14.0 corresponds to Platform version 10.0.0
 
-static PLATFORM_VER: Lazy<Version> = Lazy::new(|| Version::parse(crate::VERSION).unwrap());
-
 #[instrument(skip(request))]
 pub async fn handle_api_versions_request(
     request: RequestMessage<ApiVersionsRequest>,
 ) -> Result<ResponseMessage<ApiVersionsResponse>> {
     let mut response = ApiVersionsResponse {
-        platform_version: PlatformVersion::new(&PLATFORM_VER),
+        platform_version: PlatformVersion::new(&crate::FLUVIO_PLATFORM_VERSION),
         ..Default::default()
     };
 

crates/fluvio-sc/src/start.rs

@@ -14,7 +14,7 @@ pub fn main_loop(opt: ScOpt) {
     #[cfg(not(feature = "k8"))]
     let ((sc_config, auth_policy), tls_option) = opt.parse_cli_or_exit();
 
-    println!("Starting SC, platform: {}", crate::VERSION);
+    println!("Starting SC, platform: {}", *crate::FLUVIO_PLATFORM_VERSION);
 
     inspect_system();
 
@@ -85,7 +85,10 @@ fn inspect_system() {
 
     let mut sys = System::new_all();
     sys.refresh_all();
-    info!(version = crate::VERSION, "Platform");
+    info!(
+        version = crate::FLUVIO_PLATFORM_VERSION.to_string(),
+        "Platform"
+    );
     info!(commit = env!("GIT_HASH"), "Git");
     info!(name = ?sys.name(),"System");
     info!(kernel = ?sys.kernel_version(),"System");

crates/fluvio-spu/Cargo.toml

@@ -52,6 +52,7 @@ chrono = { workspace = true }
 fluvio = { workspace = true }
 fluvio-types = { workspace = true, features = ["events"] }
 fluvio-storage = { workspace = true }
+fluvio-common = { workspace = true }
 fluvio-compression = { workspace = true }
 fluvio-controlplane = { workspace = true }
 fluvio-controlplane-metadata = { workspace = true }

crates/fluvio-spu/src/lib.rs

@@ -17,7 +17,7 @@ cfg_if::cfg_if! {
 
 pub use config::SpuOpt;
 
-const VERSION: &str = include_str!("../../../VERSION");
+use fluvio_common::FLUVIO_PLATFORM_VERSION;
 
 pub(crate) mod traffic {
     use fluvio_protocol::api::RequestHeader;

crates/fluvio-spu/src/start.rs

@@ -30,7 +30,10 @@ pub fn main_loop(opt: SpuOpt) {
 
     let mut sys = System::new_all();
     sys.refresh_all();
-    info!(version = crate::VERSION, "Platform");
+    info!(
+        version = crate::FLUVIO_PLATFORM_VERSION.to_string(),
+        "Platform"
+    );
     info!(commit = env!("GIT_HASH"), "Git");
     info!(name = ?sys.name(),"System");
     info!(kernel = ?sys.kernel_version(),"System");

crates/fluvio-test-util/Cargo.toml

@@ -35,6 +35,7 @@ fluvio = { workspace = true  }
 fluvio-types = { workspace = true }
 fluvio-future = { workspace = true, features = ["task", "timer", "subscriber", "fixture"] }
 fluvio-cluster = { path = "../fluvio-cluster" }
+fluvio-common = { workspace = true }
 fluvio-command = { workspace = true  }
 fluvio-controlplane-metadata = { workspace = true, features = ["k8"] }
 

crates/fluvio-test-util/lib.rs

@@ -4,11 +4,13 @@ pub mod tls;
 
 pub mod test_meta;
 use once_cell::sync::Lazy;
+use semver::Version;
 
-static VERSION: Lazy<String> = Lazy::new(|| {
-    let version = include_str!("../../VERSION");
+static FLUVIO_PLATFORM_TEST_VERSION: Lazy<Version> = Lazy::new(|| {
+    let version = fluvio_common::FLUVIO_PLATFORM_VERSION.clone();
     match option_env!("FLUVIO_VERSION_SUFFIX") {
-        Some(suffix) => format!("{version}-{suffix}"),
-        None => version.to_string(),
+        Some(suffix) => Version::parse(&format!("{version}-{suffix}"))
+            .expect("Invalid value in 'FLUVIO_VERSION_SUFFIX' ENV variable."),
+        None => version,
     }
 });

crates/fluvio-test-util/setup/environment/k8.rs

@@ -30,8 +30,7 @@ impl EnvironmentDriver for K8EnvironmentDriver {
     }
 
     async fn start_cluster(&self) -> StartStatus {
-        let version = semver::Version::parse(&crate::VERSION).unwrap();
-        let mut builder = ClusterConfig::builder(version);
+        let mut builder = ClusterConfig::builder(crate::FLUVIO_PLATFORM_TEST_VERSION.clone());
         if self.option.develop_mode() {
             builder.development().expect("should test in develop mode");
         } else {