chore: Make code work again

Author: Techassi

crates/stackable-operator/src/builder/pod/resources.rs

@@ -5,7 +5,10 @@ use k8s_openapi::{
 };
 use tracing::warn;
 
-use crate::{commons::resources::ResourceRequirementsType, quantity::CpuQuantity};
+use crate::{
+    commons::resources::ResourceRequirementsType,
+    quantity::{CpuQuantity, MemoryQuantity, ParseQuantityError},
+};
 
 const RESOURCE_DENYLIST: &[&str] = &["cpu", "memory"];
 
@@ -50,7 +53,7 @@ impl<CL, MR, ML> ResourceRequirementsBuilder<(), CL, MR, ML> {
         self,
         request: impl Into<String>,
         factor: f32,
-    ) -> cpu::Result<ResourceRequirementsBuilder<Quantity, Quantity, MR, ML>> {
+    ) -> Result<ResourceRequirementsBuilder<Quantity, Quantity, MR, ML>, ParseQuantityError> {
         let request = CpuQuantity::from_str(&request.into())?;
         let limit = request * factor;
 
@@ -120,7 +123,7 @@ impl<CR, CL, ML> ResourceRequirementsBuilder<CL, CR, (), ML> {
         self,
         request: impl Into<String>,
         factor: f32,
-    ) -> memory::Result<ResourceRequirementsBuilder<CL, CR, Quantity, Quantity>> {
+    ) -> Result<ResourceRequirementsBuilder<CL, CR, Quantity, Quantity>, ParseQuantityError> {
         let request = MemoryQuantity::from_str(&request.into())?;
         let limit = request * factor;
 

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

@@ -67,28 +67,34 @@
 //!     shared_storage: PvcConfig,
 //! }
 //! ```
+use std::{collections::BTreeMap, fmt::Debug};
 
 use educe::Educe;
-use k8s_openapi::api::core::v1::{
-    Container, PersistentVolumeClaim, PersistentVolumeClaimSpec, PodSpec, ResourceRequirements,
-    VolumeResourceRequirements,
+use k8s_openapi::{
+    api::core::v1::{
+        Container, PersistentVolumeClaim, PersistentVolumeClaimSpec, PodSpec, ResourceRequirements,
+        VolumeResourceRequirements,
+    },
+    apimachinery::pkg::{
+        api::resource::Quantity,
+        apis::meta::v1::{LabelSelector, ObjectMeta},
+    },
 };
-use k8s_openapi::apimachinery::pkg::api::resource::Quantity;
-use k8s_openapi::apimachinery::pkg::apis::meta::v1::{LabelSelector, ObjectMeta};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use snafu::{ResultExt, Snafu};
-use std::{collections::BTreeMap, fmt::Debug};
 use strum::Display;
 
-use crate::config::{
-    fragment::{Fragment, FromFragment},
-    merge::Merge,
+use crate::{
+    config::{
+        fragment::{Fragment, FromFragment},
+        merge::Merge,
+    },
+    quantity::{CpuQuantity, MemoryQuantity, ParseQuantityError},
 };
-use crate::quantity::{CpuQuantity, MemoryQuantity};
 
-pub const LIMIT_REQUEST_RATIO_CPU: f32 = 5.0;
-pub const LIMIT_REQUEST_RATIO_MEMORY: f32 = 1.0;
+pub const LIMIT_REQUEST_RATIO_CPU: f64 = 5.0;
+pub const LIMIT_REQUEST_RATIO_MEMORY: f64 = 1.0;
 
 type Result<T, E = Error> = std::result::Result<T, E>;
 
@@ -107,20 +113,20 @@ pub enum Error {
     LimitToRequestRatioExceeded {
         container_name: String,
         resource_key: String,
-        allowed_ration: f32,
+        allowed_ration: f64,
     },
 
     #[snafu(display("failed to convert Quantity to CpuQuantity for cpu limit"))]
-    CpuLimit { source: crate::cpu::Error },
+    CpuLimit { source: ParseQuantityError },
 
     #[snafu(display("failed to convert Quantity to CpuQuantity for cpu request"))]
-    CpuRequest { source: crate::cpu::Error },
+    CpuRequest { source: ParseQuantityError },
 
     #[snafu(display("failed to convert Quantity to MemoryQuantity for memory limit"))]
-    MemoryLimit { source: crate::memory::Error },
+    MemoryLimit { source: ParseQuantityError },
 
     #[snafu(display("failed to convert Quantity to MemoryQuantity for memory request"))]
-    MemoryRequest { source: crate::memory::Error },
+    MemoryRequest { source: ParseQuantityError },
 }
 
 /// Resource usage is configured here, this includes CPU usage, memory usage and disk storage
@@ -427,7 +433,7 @@ pub trait ResourceRequirementsExt {
         &self,
         resource: &ComputeResource,
         // We did choose a f32 instead of a usize here, as LimitRange ratios can be a floating point (Quantity - e.g. 1500m)
-        ratio: f32,
+        ratio: f64,
     ) -> Result<()>;
 }
 
@@ -457,7 +463,7 @@ impl ResourceRequirementsExt for Container {
         Ok(())
     }
 
-    fn check_limit_to_request_ratio(&self, resource: &ComputeResource, ratio: f32) -> Result<()> {
+    fn check_limit_to_request_ratio(&self, resource: &ComputeResource, ratio: f64) -> Result<()> {
         let limit = self
             .resources
             .as_ref()
@@ -509,7 +515,7 @@ impl ResourceRequirementsExt for PodSpec {
         Ok(())
     }
 
-    fn check_limit_to_request_ratio(&self, resource: &ComputeResource, ratio: f32) -> Result<()> {
+    fn check_limit_to_request_ratio(&self, resource: &ComputeResource, ratio: f64) -> Result<()> {
         for container in &self.containers {
             container.check_limit_to_request_ratio(resource, ratio)?;
         }

crates/stackable-operator/src/product_logging/framework.rs

@@ -101,17 +101,16 @@ pub enum LoggingError {
 ///     .unwrap();
 /// ```
 pub fn calculate_log_volume_size_limit(max_log_files_size: &[MemoryQuantity]) -> Quantity {
-    let log_volume_size_limit = max_log_files_size
-        .iter()
-        .cloned()
-        .sum::<MemoryQuantity>()
-        .scale_to(Suffix::BinaryByteMultiple(BinaryByteMultiple::Mebi))
+    let mut log_volume_size_limit = max_log_files_size.iter().cloned().sum::<MemoryQuantity>();
+    log_volume_size_limit.scale_to(Suffix::BinaryByteMultiple(BinaryByteMultiple::Mebi));
+    log_volume_size_limit
         // According to the reasons mentioned in the function documentation, the multiplier must be
         // greater than 2. Manual tests with ZooKeeper 3.8 in an OpenShift cluster showed that 3 is
         // absolutely sufficient.
-        .mul(3.0)
+        .mul(3.0f32)
         // Avoid bulky numbers due to the floating-point arithmetic.
         .ceil();
+
     log_volume_size_limit.into()
 }
 

crates/stackable-operator/src/quantity/cpu.rs

@@ -10,7 +10,7 @@ use crate::quantity::{
     DecimalByteMultiple, ParseQuantityError, Quantity, Suffix,
 };
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
 pub struct CpuQuantity(Quantity);
 
 impl Deref for CpuQuantity {

crates/stackable-operator/src/quantity/memory.rs

@@ -18,7 +18,7 @@ pub trait JavaHeap {
     fn to_java_heap_string(&self) -> Result<String, String>;
 }
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
 pub struct MemoryQuantity(Quantity);
 
 impl Deref for MemoryQuantity {

crates/stackable-operator/src/quantity/mod.rs

@@ -16,7 +16,7 @@ mod ops;
 pub use cpu::*;
 pub use memory::*;
 
-#[derive(Debug, Snafu)]
+#[derive(Debug, PartialEq, Snafu)]
 pub enum ParseQuantityError {
     #[snafu(display("input is either empty or contains non-ascii characters"))]
     InvalidFormat,
@@ -28,7 +28,7 @@ pub enum ParseQuantityError {
     InvalidSuffix { source: ParseSuffixError },
 }
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
 pub struct Quantity {
     // FIXME (@Techassi): Support arbitrary-precision numbers
     /// The numeric value of the quantity.
@@ -138,22 +138,26 @@ impl Quantity {
                 let factor = (s.base() as f64).powf(s.exponent())
                     / (suffix.base() as f64).powf(suffix.exponent());
 
-                *v = *v * factor;
+                *v *= factor;
                 *s = suffix;
 
                 false
             }
         }
     }
+
+    pub fn ceil(&mut self) {
+        self.value = self.value.ceil();
+    }
 }
 
-#[derive(Debug, Snafu)]
+#[derive(Debug, PartialEq, Snafu)]
 #[snafu(display("failed to parse {input:?} as quantity suffix"))]
 pub struct ParseSuffixError {
     input: String,
 }
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
 pub enum Suffix {
     DecimalByteMultiple(DecimalByteMultiple),
     BinaryByteMultiple(BinaryByteMultiple),
@@ -244,7 +248,7 @@ pub trait SuffixMultiple {
 /// - <https://physics.nist.gov/cuu/Units/binary.html>
 ///
 /// [k8s-serialization-format]: https://github.com/kubernetes/apimachinery/blob/8c60292e48e46c4faa1e92acb232ce6adb37512c/pkg/api/resource/quantity.go#L37-L59
-#[derive(Clone, Debug, PartialEq, strum::Display, strum::EnumString)]
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, strum::Display, strum::EnumString)]
 pub enum BinaryByteMultiple {
     #[strum(serialize = "Ki")]
     Kibi,
@@ -310,7 +314,7 @@ impl SuffixMultiple for BinaryByteMultiple {
 /// - <https://physics.nist.gov/cuu/Units/binary.html>
 ///
 /// [k8s-serialization-format]: https://github.com/kubernetes/apimachinery/blob/8c60292e48e46c4faa1e92acb232ce6adb37512c/pkg/api/resource/quantity.go#L37-L59
-#[derive(Clone, Debug, PartialEq, strum::Display, strum::EnumString)]
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, strum::Display, strum::EnumString)]
 pub enum DecimalByteMultiple {
     #[strum(serialize = "m")]
     Milli,
@@ -355,7 +359,7 @@ impl SuffixMultiple for DecimalByteMultiple {
 /// ### See
 ///
 /// - <https://en.wikipedia.org/wiki/Scientific_notation#E_notation>
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
 pub struct DecimalExponent(f64);
 
 impl Deref for DecimalExponent {
@@ -471,10 +475,10 @@ mod test {
         #[case] output: &str,
         #[case] scaled: bool,
     ) {
-        let parsed = Quantity::from_str(input).unwrap();
-        let (quantity, was_scaled) = parsed.scale_to(Suffix::BinaryByteMultiple(scale_to));
+        let mut parsed = Quantity::from_str(input).unwrap();
+        let was_scaled = parsed.scale_to(Suffix::BinaryByteMultiple(scale_to));
 
-        assert_eq!(quantity.to_string(), output);
+        assert_eq!(parsed.to_string(), output);
         assert_eq!(was_scaled, scaled);
     }
 
@@ -487,10 +491,10 @@ mod test {
         #[case] output: &str,
         #[case] scaled: bool,
     ) {
-        let parsed = Quantity::from_str(input).unwrap();
-        let (quantity, was_scaled) = parsed.scale_to(Suffix::DecimalByteMultiple(scale_to));
+        let mut parsed = Quantity::from_str(input).unwrap();
+        let was_scaled = parsed.scale_to(Suffix::DecimalByteMultiple(scale_to));
 
-        assert_eq!(quantity.to_string(), output);
+        assert_eq!(parsed.to_string(), output);
         assert_eq!(was_scaled, scaled);
     }
 
@@ -504,10 +508,10 @@ mod test {
         #[case] output: &str,
         #[case] scaled: bool,
     ) {
-        let parsed = Quantity::from_str(input).unwrap();
-        let (quantity, was_scaled) = parsed.scale_to(Suffix::DecimalByteMultiple(scale_to));
+        let mut parsed = Quantity::from_str(input).unwrap();
+        let was_scaled = parsed.scale_to(Suffix::DecimalByteMultiple(scale_to));
 
-        assert_eq!(quantity.to_string(), output);
+        assert_eq!(parsed.to_string(), output);
         assert_eq!(was_scaled, scaled);
     }
 
@@ -521,10 +525,10 @@ mod test {
         #[case] output: &str,
         #[case] scaled: bool,
     ) {
-        let parsed = Quantity::from_str(input).unwrap();
-        let (quantity, was_scaled) = parsed.scale_to(Suffix::DecimalExponent(scale_to));
+        let mut parsed = Quantity::from_str(input).unwrap();
+        let was_scaled = parsed.scale_to(Suffix::DecimalExponent(scale_to));
 
-        assert_eq!(quantity.to_string(), output);
+        assert_eq!(parsed.to_string(), output);
         assert_eq!(was_scaled, scaled);
     }
 }