refactor: Replace lazy_static with std::sync::LazyLock (#840)

* refactor: Replace lazy_static with std::sync::LazyLock

* update changelog

* bump to 0.80.1

* Mention all PRs in crates/k8s-version/CHANGELOG.md

* Mention Techassi

Co-authored-by: Techassi <[email protected]>

---------

Co-authored-by: Techassi <[email protected]>

Author: sbernauer

.github/workflows/build.yml

@@ -17,7 +17,7 @@ env:
   CARGO_TERM_COLOR: always
   CARGO_INCREMENTAL: '0'
   CARGO_PROFILE_DEV_DEBUG: '0'
-  RUST_TOOLCHAIN_VERSION: "1.79.0"
+  RUST_TOOLCHAIN_VERSION: "1.80.1"
   RUSTFLAGS: "-D warnings"
   RUSTDOCFLAGS: "-D warnings"
   RUST_LOG: "info"
@@ -37,7 +37,7 @@ jobs:
       - uses: Swatinem/rust-cache@23bce251a8cd2ffc3c1075eaa2367cf899916d84 # v2.7.3
         with:
           key: udeps
-      - run: cargo install --locked [email protected].47
+      - run: cargo install --locked [email protected].50
       - run: cargo udeps --all-targets
 
   run_cargodeny:

.github/workflows/pr_pre-commit.yaml

@@ -6,7 +6,7 @@ on:
 
 env:
   CARGO_TERM_COLOR: always
-  RUST_TOOLCHAIN_VERSION: "1.79.0"
+  RUST_TOOLCHAIN_VERSION: "1.80.1"
 
 jobs:
   pre-commit:

Cargo.lock

@@ -32,7 +32,6 @@ json-patch = "2.0.0"
 k8s-openapi = { version = "0.22.0", default-features = false, features = ["schemars", "v1_30"] }
 # We use rustls instead of openssl for easier portablitly, e.g. so that we can build stackablectl without the need to vendor (build from source) openssl
 kube = { version = "0.93.1", default-features = false, features = ["client", "jsonpatch", "runtime", "derive", "rustls-tls"] }
-lazy_static = "1.5.0"
 opentelemetry = "0.23.0"
 opentelemetry_sdk = { version = "0.23.0", features = ["rt-tokio"] }
 opentelemetry-appender-tracing = "0.4.0"

Cargo.toml

@@ -4,6 +4,14 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+### Changed
+
+- Replace `lazy_static` with `std::cell::LazyCell` ([#827], [#835], [#840]).
+
+[#827]: https://github.com/stackabletech/operator-rs/pull/827
+[#835]: https://github.com/stackabletech/operator-rs/pull/835
+[#840]: https://github.com/stackabletech/operator-rs/pull/840
+
 ## [0.1.1] - 2024-07-10
 
 ### Changed

crates/k8s-version/CHANGELOG.md

@@ -11,7 +11,6 @@ darling = ["dep:darling"]
 
 [dependencies]
 darling = { workspace = true, optional = true }
-lazy_static.workspace = true
 regex.workspace = true
 snafu.workspace = true
 

crates/k8s-version/Cargo.toml

@@ -1,16 +1,14 @@
-use std::{fmt, ops::Deref, str::FromStr};
+use std::{fmt, ops::Deref, str::FromStr, sync::LazyLock};
 
-use lazy_static::lazy_static;
 use regex::Regex;
 use snafu::{ensure, Snafu};
 
 const MAX_GROUP_LENGTH: usize = 253;
 
-lazy_static! {
-    static ref API_GROUP_REGEX: Regex =
-        Regex::new(r"^(?:(?:[a-z0-9][a-z0-9-]{0,61}[a-z0-9])\.?)+$")
-            .expect("failed to compile API group regex");
-}
+static API_GROUP_REGEX: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(r"^(?:(?:[a-z0-9][a-z0-9-]{0,61}[a-z0-9])\.?)+$")
+        .expect("failed to compile API group regex")
+});
 
 /// Error variants which can be encountered when creating a new [`Group`] from
 /// unparsed input.

crates/k8s-version/src/group.rs

@@ -4,19 +4,18 @@ use std::{
     num::ParseIntError,
     ops::{Add, AddAssign, Sub, SubAssign},
     str::FromStr,
+    sync::LazyLock,
 };
 
-use lazy_static::lazy_static;
 use regex::Regex;
 use snafu::{OptionExt, ResultExt, Snafu};
 
 #[cfg(feature = "darling")]
 use darling::FromMeta;
 
-lazy_static! {
-    static ref LEVEL_REGEX: Regex = Regex::new(r"^(?P<identifier>[a-z]+)(?P<version>\d+)$")
-        .expect("failed to compile level regex");
-}
+static LEVEL_REGEX: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(r"^(?P<identifier>[a-z]+)(?P<version>\d+)$").expect("failed to compile level regex")
+});
 
 /// Error variants which can be encountered when creating a new [`Level`] from
 /// unparsed input.

crates/k8s-version/src/level.rs

@@ -1,6 +1,5 @@
-use std::{cmp::Ordering, fmt::Display, num::ParseIntError, str::FromStr};
+use std::{cmp::Ordering, fmt::Display, num::ParseIntError, str::FromStr, sync::LazyLock};
 
-use lazy_static::lazy_static;
 use regex::Regex;
 use snafu::{OptionExt, ResultExt, Snafu};
 
@@ -9,11 +8,10 @@ use darling::FromMeta;
 
 use crate::{Level, ParseLevelError};
 
-lazy_static! {
-    static ref VERSION_REGEX: Regex =
-        Regex::new(r"^v(?P<major>\d+)(?P<level>[a-z0-9][a-z0-9-]{0,60}[a-z0-9])?$")
-            .expect("failed to compile version regex");
-}
+static VERSION_REGEX: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(r"^v(?P<major>\d+)(?P<level>[a-z0-9][a-z0-9-]{0,60}[a-z0-9])?$")
+        .expect("failed to compile version regex")
+});
 
 /// Error variants which can be encountered when creating a new [`Version`] from
 /// unparsed input.

crates/k8s-version/src/version.rs

@@ -4,6 +4,8 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+- BREAKING: Replace `lazy_static` with `std::cell::LazyCell` (the original implementation was done in [#827] and reverted in [#835]) ([#840]).
+
 ### Added
 
 - `iter::reverse_if` helper ([#838]).
@@ -18,7 +20,7 @@ All notable changes to this project will be documented in this file.
 
 ### Changed
 
-- Reverted [#827], in order to restore Rust 1.79 compatibility for now ([#835]).
+- Reverted [#827], in order to restore Rust 1.79 compatibility for now ([#835]), re-opened in ([#840]).
 
 ### Fixed
 
@@ -32,7 +34,7 @@ All notable changes to this project will be documented in this file.
 
 ### Changed
 
-- BREAKING: Replace `lazy_static` with `std::cell::LazyCell` ([#827]).
+- BREAKING: Replace `lazy_static` with `std::cell::LazyCell` ([#827], [#835], [#840]).
 - BREAKING: Convert `podOverrides` and `affinity` fields to take any arbitrary
   YAML input, rather than using the underlying schema. With this change, one of
   the larger CRDs, like the Druid CRD went down in size from `2.4MB` to `288K`
@@ -44,6 +46,7 @@ All notable changes to this project will be documented in this file.
 
 [#821]: https://github.com/stackabletech/operator-rs/pull/821
 [#827]: https://github.com/stackabletech/operator-rs/pull/827
+[#840]: https://github.com/stackabletech/operator-rs/pull/840
 
 ## [0.71.0] - 2024-07-29
 

crates/stackable-operator/CHANGELOG.md

@@ -24,7 +24,6 @@ futures.workspace = true
 json-patch.workspace = true
 k8s-openapi.workspace = true
 kube.workspace = true
-lazy_static.workspace = true
 opentelemetry_sdk.workspace = true
 opentelemetry-jaeger.workspace = true
 product-config.workspace = true

crates/stackable-operator/Cargo.toml

@@ -373,15 +373,15 @@ impl Client {
 
     /// There are four different patch strategies:
     /// 1) Apply (<https://kubernetes.io/docs/reference/using-api/api-concepts/#server-side-apply>)
-    ///   Starting from Kubernetes v1.18, you can enable the Server Side Apply feature so that the control plane tracks managed fields for all newly created objects.
+    ///    Starting from Kubernetes v1.18, you can enable the Server Side Apply feature so that the control plane tracks managed fields for all newly created objects.
     /// 2) Json (<https://tools.ietf.org/html/rfc6902>):
-    ///   This is supported on crate feature jsonpatch only
+    ///    This is supported on crate feature jsonpatch only
     /// 3) Merge (<https://tools.ietf.org/html/rfc7386>):
-    ///   For example, if you want to update a list you have to specify the complete list and update everything
+    ///    For example, if you want to update a list you have to specify the complete list and update everything
     /// 4) Strategic (not for CustomResource)
-    ///   With a strategic merge patch, a list is either replaced or merged depending on its patch strategy.
-    ///   The patch strategy is specified by the value of the patchStrategy key in a field tag in the Kubernetes source code.
-    ///   For example, the Containers field of PodSpec struct has a patchStrategy of merge.
+    ///    With a strategic merge patch, a list is either replaced or merged depending on its patch strategy.
+    ///    The patch strategy is specified by the value of the patchStrategy key in a field tag in the Kubernetes source code.
+    ///    For example, the Containers field of PodSpec struct has a patchStrategy of merge.
     async fn patch_status<T, S>(
         &self,
         resource: &T,

crates/stackable-operator/src/client.rs

@@ -110,7 +110,7 @@ pub enum KubernetesTrafficPolicy {
 /// 1. It uses a cluster-level policy object (ListenerClass) to define how exactly the exposure works
 /// 2. It has a consistent API for reading back the exposed address(es) of the service
 /// 3. The Pod must mount a Volume referring to the Listener, which also allows
-/// ["sticky" scheduling](DOCS_BASE_URL_PLACEHOLDER/listener-operator/listener#_sticky_scheduling).
+///    ["sticky" scheduling](DOCS_BASE_URL_PLACEHOLDER/listener-operator/listener#_sticky_scheduling).
 ///
 /// Learn more in the [Listener documentation](DOCS_BASE_URL_PLACEHOLDER/listener-operator/listener).
 #[derive(

crates/stackable-operator/src/commons/listener.rs

@@ -43,15 +43,23 @@
 //! assert_eq!(opa_config.document_url(&cluster, Some("allow"), OpaApiVersion::V1), "v1/data/test/allow".to_string());
 //! assert_eq!(opa_config.full_document_url(&cluster, "http://localhost:8081", None, OpaApiVersion::V1), "http://localhost:8081/v1/data/test".to_string());
 //! ```
+use std::sync::LazyLock;
+
 use crate::client::{Client, GetApi};
 use k8s_openapi::{api::core::v1::ConfigMap, NamespaceResourceScope};
 use kube::{Resource, ResourceExt};
-use lazy_static::lazy_static;
 use regex::Regex;
 use schemars::{self, JsonSchema};
 use serde::{Deserialize, Serialize};
 use snafu::{OptionExt, ResultExt, Snafu};
 
+static DOT_REGEX: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new("\\.").expect("failed to compile OPA dot regex"));
+
+/// To remove leading slashes from OPA package name (if present)
+static LEADING_SLASH_REGEX: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new("(/*)(.*)").expect("failed to compile OPA leasing slash regex"));
+
 type Result<T, E = Error> = std::result::Result<T, E>;
 
 #[derive(Debug, Snafu)]
@@ -72,11 +80,6 @@ pub enum Error {
     },
 }
 
-lazy_static! {
-    static ref DOT_REGEX: Regex = Regex::new("\\.").unwrap();
-    /// To remove leading slashes from OPA package name (if present)
-    static ref LEADING_SLASH_REGEX: Regex = Regex::new("(/*)(.*)").unwrap();
-}
 /// Indicates the OPA API version. This is required to choose the correct
 /// path when constructing the OPA urls to query.
 pub enum OpaApiVersion {

crates/stackable-operator/src/commons/opa.rs

@@ -101,12 +101,14 @@ impl Display for CpuQuantity {
 impl FromStr for CpuQuantity {
     type Err = Error;
 
-    /// Only two formats can be parsed
+    /// Only two formats can be parsed:
+    ///
     /// - {usize}m
     /// - {f32}
-    /// For the float, only milli-precision is supported.
-    /// Using more precise values will trigger an error, and using any other
-    /// unit than 'm' or None will also trigger an error.
+    ///
+    /// For the float, only milli-precision is supported. Using more precise
+    /// values will trigger an error, and using any other unit than 'm' or None
+    /// will also trigger an error.
     fn from_str(q: &str) -> Result<Self> {
         let start_of_unit = q.find(|c: char| c != '.' && !c.is_numeric());
         if let Some(start_of_unit) = start_of_unit {

crates/stackable-operator/src/cpu.rs

@@ -1,18 +1,21 @@
-use std::{fmt::Display, ops::Deref, str::FromStr};
+use std::{fmt::Display, ops::Deref, str::FromStr, sync::LazyLock};
 
-use lazy_static::lazy_static;
 use regex::Regex;
 use snafu::{ensure, ResultExt, Snafu};
 
 const KEY_PREFIX_MAX_LEN: usize = 253;
 const KEY_NAME_MAX_LEN: usize = 63;
 
-lazy_static! {
-    static ref KEY_PREFIX_REGEX: Regex =
-        Regex::new(r"^[a-zA-Z](\.?[a-zA-Z0-9-])*\.[a-zA-Z]{2,}\.?$").unwrap();
-    static ref KEY_NAME_REGEX: Regex =
-        Regex::new(r"^[a-z0-9A-Z]([a-z0-9A-Z-_.]*[a-z0-9A-Z]+)?$").unwrap();
-}
+// Lazily initialized regular expressions
+static KEY_PREFIX_REGEX: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(r"^[a-zA-Z](\.?[a-zA-Z0-9-])*\.[a-zA-Z]{2,}\.?$")
+        .expect("failed to compile key prefix regex")
+});
+
+static KEY_NAME_REGEX: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(r"^[a-z0-9A-Z]([a-z0-9A-Z-_.]*[a-z0-9A-Z]+)?$")
+        .expect("failed to compile key name regex")
+});
 
 /// The error type for key parsing/validation operations.
 ///

crates/stackable-operator/src/kvp/key.rs

@@ -1,17 +1,17 @@
-use std::{fmt::Display, ops::Deref, str::FromStr};
+use std::{fmt::Display, ops::Deref, str::FromStr, sync::LazyLock};
 
-use lazy_static::lazy_static;
 use regex::Regex;
 use snafu::{ensure, Snafu};
 
 use crate::kvp::Value;
 
 const LABEL_VALUE_MAX_LEN: usize = 63;
 
-lazy_static! {
-    static ref LABEL_VALUE_REGEX: Regex =
-        Regex::new(r"^[a-z0-9A-Z]([a-z0-9A-Z-_.]*[a-z0-9A-Z]+)?$").unwrap();
-}
+// Lazily initialized regular expressions
+static LABEL_VALUE_REGEX: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(r"^[a-z0-9A-Z]([a-z0-9A-Z-_.]*[a-z0-9A-Z]+)?$")
+        .expect("failed to compile value regex")
+});
 
 /// The error type for label value parse/validation operations.
 #[derive(Debug, PartialEq, Snafu)]

crates/stackable-operator/src/kvp/label/value.rs

@@ -1,7 +1,7 @@
 //! Utilities for converting Kubernetes quantities to Java heap settings.
 //! Since Java heap sizes are a subset of Kubernetes quantities, the conversion
-//! might lose precision or fail completely.
-//! In addition:
+//! might lose precision or fail completely. In addition:
+//!
 //! - decimal quantities are not supported ("2G" is invalid)
 //! - units are case sensitive ("2gi" is invalid)
 //! - exponential notation is not supported.
@@ -121,12 +121,15 @@ impl Display for BinaryMultiple {
 }
 
 /// Convert a (memory) [`Quantity`] to Java heap settings.
+///
 /// Quantities are usually passed on to container resources while Java heap
-/// sizes need to be scaled accordingly.
-/// This implements a very simple heuristic to ensure that:
+/// sizes need to be scaled accordingly. This implements a very simple heuristic
+/// to ensure that:
+///
 /// - the quantity unit has been mapped to a java supported heap unit. Java only
 ///   supports up to Gibibytes while K8S quantities can be expressed in Exbibytes.
 /// - the heap size has a non-zero value.
+///
 /// Fails if it can't enforce the above restrictions.
 #[deprecated(
     since = "0.33.0",
@@ -148,15 +151,17 @@ pub fn to_java_heap(q: &Quantity, factor: f32) -> Result<String> {
 }
 
 /// Convert a (memory) [`Quantity`] to a raw Java heap value of the desired `target_unit`.
+///
 /// Quantities are usually passed on to container resources while Java heap
-/// sizes need to be scaled accordingly.
-/// The raw heap value is converted to the specified `target_unit` (this conversion
-/// is done even if specified a unit greater that Gibibytes. It is not recommended to scale
-/// to anything bigger than Gibibytes.
-/// This implements a very simple heuristic to ensure that:
+/// sizes need to be scaled accordingly. The raw heap value is converted to the
+/// specified `target_unit` (this conversion is done even if specified a unit
+/// greater that Gibibytes. It is not recommended to scale to anything bigger
+/// than Gibibytes. This implements a very simple heuristic to ensure that:
+///
 /// - the quantity unit has been mapped to a java supported heap unit. Java only
 ///   supports up to Gibibytes while K8S quantities can be expressed in Exbibytes.
 /// - the heap size has a non-zero value.
+///
 /// Fails if it can't enforce the above restrictions.
 #[deprecated(
     since = "0.33.0",