feat(stackable-operator): Add EoS checker skeleton

Author: Techassi

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

@@ -0,0 +1,109 @@
+use chrono::{DateTime, Utc};
+use stackable_shared::time::Duration;
+
+/// Available options to configure a [`EndOfSupportChecker`].
+///
+/// Additionally, this struct can be used as operator CLI arguments. This functionality is only
+/// available if the feature `clap` is enabled.
+#[cfg_attr(feature = "clap", derive(clap::Args))]
+#[derive(Debug, PartialEq, Eq)]
+pub struct EndOfSupportOptions {
+    /// The end-of-support check mode. Currently, only "offline" is supported.
+    #[arg(
+        long = "eos-check-mode",
+        env = "EOS_CHECK_MODE",
+        default_value_t = EndOfSupportCheckMode::default(),
+        value_enum
+    )]
+    pub check_mode: EndOfSupportCheckMode,
+
+    /// The interval in which the end-of-support check should run.
+    #[arg(
+        long = "eos-interval",
+        env = "EOS_INTERVAL",
+        default_value_t = Self::default_interval()
+    )]
+    pub interval: Duration,
+
+    /// The support duration (how long the operator should be considered supported after
+    /// it's built-date).
+    ///
+    /// This field is currently not exposed as a CLI argument or environment variable. The default
+    /// value is provided by [`Self::default_support_duration()`].
+    #[arg(skip = Self::default_support_duration())]
+    pub support_duration: Duration,
+}
+
+impl EndOfSupportOptions {
+    fn default_interval() -> Duration {
+        Duration::from_days_unchecked(1)
+    }
+
+    fn default_support_duration() -> Duration {
+        Duration::from_days_unchecked(365)
+    }
+}
+
+#[cfg_attr(feature = "clap", derive(clap::ValueEnum))]
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub enum EndOfSupportCheckMode {
+    #[default]
+    Offline,
+}
+
+pub enum Error {}
+
+pub struct EndOfSupportChecker {
+    check_mode: EndOfSupportCheckMode,
+    datetime: DateTime<Utc>,
+    interval: Duration,
+}
+
+impl EndOfSupportChecker {
+    /// Creates and returns a new end-of-support checker.
+    pub fn new(built_time: &str, options: EndOfSupportOptions) -> Result<Self, Error> {
+        let EndOfSupportOptions {
+            check_mode,
+            interval,
+            support_duration,
+        } = options;
+
+        // Parse the built-time from the RFC2822-encoded string and add the support duration to it.
+        // This is datetime marks the end-of-support date.
+        let datetime =
+            DateTime::parse_from_rfc2822(built_time).unwrap().to_utc() + *support_duration;
+
+        Ok(Self {
+            check_mode,
+            datetime,
+            interval,
+        })
+    }
+
+    /// Run the end-of-support checker.
+    pub async fn run(self) {
+        // Construct an interval which can be polled.
+        let mut interval = tokio::time::interval(self.interval.into());
+
+        loop {
+            // TODO: Add way to stop from the outside
+            // The first tick ticks immediately.
+            interval.tick().await;
+
+            if !self.is_eos() {
+                continue;
+            }
+
+            match self.check_mode {
+                EndOfSupportCheckMode::Offline => todo!(),
+            }
+        }
+    }
+
+    /// Returns if the operator is considered as end-of-support based on the built-time and the
+    /// support duration.
+    fn is_eos(&self) -> bool {
+        let now = Utc::now();
+        now > self.datetime
+    }
+}

crates/stackable-operator/src/lib.rs

@@ -15,6 +15,7 @@ pub mod config;
 pub mod constants;
 pub mod cpu;
 pub mod crd;
+pub mod eos;
 pub mod helm;
 pub mod iter;
 pub mod kvp;