Expire unversioned environments

Signed-off-by: itowlson <ivan.towlson@fermyon.com>

Author: itowlson

Cargo.lock

@@ -8,6 +8,7 @@ edition = { workspace = true }
 anyhow = { workspace = true }
 async-trait = "0.1"
 bytes = "1.1"
+chrono = { workspace = true }
 futures = "0.3"
 futures-util = "0.3"
 id-arena = "2"

crates/environments/Cargo.toml

@@ -189,4 +189,8 @@ impl CandidateWorld {
     }
 }
 
+pub(super) fn is_versioned(env_id: &str) -> bool {
+    env_id.contains(':')
+}
+
 pub type TriggerType = String;

crates/environments/src/environment.rs

@@ -11,7 +11,7 @@ use anyhow::Context;
 /// An environment definition, usually deserialised from a TOML document.
 /// Example:
 ///
-/// ```
+/// ```ignore
 /// # spin-up.3.2.toml
 /// [triggers]
 /// http = ["spin:up/http-trigger@3.2.0", "spin:up/http-trigger-rc20231018@3.2.0"]

crates/environments/src/environment/definition.rs

@@ -6,7 +6,7 @@ use spin_manifest::schema::v2::TargetEnvironmentRef;
 
 use super::definition::{EnvironmentDefinition, WorldName, WorldRef};
 use super::lockfile::TargetEnvironmentLockfile;
-use super::{CandidateWorld, CandidateWorlds, TargetEnvironment, UnknownTrigger};
+use super::{is_versioned, CandidateWorld, CandidateWorlds, TargetEnvironment, UnknownTrigger};
 
 const DEFAULT_ENV_DEF_REGISTRY: &str = "ghcr.io/itowlson/envs";
 const DEFAULT_PACKAGE_REGISTRY: &str = "spinframework.dev";
@@ -162,7 +162,16 @@ async fn load_env_def_toml_from_registry(
 
 async fn download_env_def_file(registry: &str, env_id: &str) -> anyhow::Result<(Vec<u8>, String)> {
     // This implies env_id is in the format spin-up:3.2 which WHO KNOWS
-    let reference = format!("{registry}/{env_id}");
+    let registry_id = if is_versioned(env_id) {
+        env_id.to_string()
+    } else {
+        // Testing versionless tags with GHCR it didn't work
+        // TODO: is this expected or am I being a dolt
+        // TODO: is this a suitable workaround
+        format!("{env_id}:latest")
+    };
+
+    let reference = format!("{registry}/{registry_id}");
     let reference = oci_distribution::Reference::try_from(reference)?;
 
     let config = oci_distribution::client::ClientConfig::default();

crates/environments/src/environment/env_loader.rs

@@ -1,30 +1,54 @@
 use std::collections::HashMap;
 
+use super::is_versioned;
+
+const DIGEST_TTL_HOURS: i64 = 24;
+
 /// Serialisation format for the lockfile: registry -> env|pkg -> { name -> digest }
 #[derive(Clone, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub struct TargetEnvironmentLockfile(HashMap<String, Digests>);
 
 #[derive(Clone, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 struct Digests {
-    env: HashMap<String, String>,
+    env: HashMap<String, ExpirableDigest>,
     package: HashMap<String, String>,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[serde(untagged)]
+enum ExpirableDigest {
+    Forever(String),
+    Expiring {
+        digest: String,
+        correct_at: chrono::DateTime<chrono::Utc>,
+    },
+}
+
 impl TargetEnvironmentLockfile {
     pub fn env_digest(&self, registry: &str, env_id: &str) -> Option<&str> {
         self.0
             .get(registry)
             .and_then(|ds| ds.env.get(env_id))
-            .map(|s| s.as_str())
+            .and_then(|s| s.current())
     }
 
     pub fn set_env_digest(&mut self, registry: &str, env_id: &str, digest: &str) {
+        // If the environment is versioned, we assume it will not change (that is, any changes will
+        // be reflected as a new version).  If the environment is *not* versioned, it represents
+        // a hosted service which may change over time: allow the cached definition to expire every day or
+        // so that we do not use a definition that is out of sync with the actual service.
+        let expirable_digest = if is_versioned(env_id) {
+            ExpirableDigest::forever(digest)
+        } else {
+            ExpirableDigest::expiring(digest)
+        };
+
         match self.0.get_mut(registry) {
             Some(ds) => {
-                ds.env.insert(env_id.to_string(), digest.to_string());
+                ds.env.insert(env_id.to_string(), expirable_digest);
             }
             None => {
-                let map = vec![(env_id.to_string(), digest.to_string())]
+                let map = vec![(env_id.to_string(), expirable_digest)]
                     .into_iter()
                     .collect();
                 let ds = Digests {
@@ -70,3 +94,31 @@ impl TargetEnvironmentLockfile {
         }
     }
 }
+
+impl ExpirableDigest {
+    fn current(&self) -> Option<&str> {
+        match self {
+            Self::Forever(digest) => Some(digest),
+            Self::Expiring { digest, correct_at } => {
+                let now = chrono::Utc::now();
+                let time_since = now - correct_at;
+                if time_since.abs().num_hours() > DIGEST_TTL_HOURS {
+                    None
+                } else {
+                    Some(digest)
+                }
+            }
+        }
+    }
+
+    fn forever(digest: &str) -> Self {
+        Self::Forever(digest.to_string())
+    }
+
+    fn expiring(digest: &str) -> Self {
+        Self::Expiring {
+            digest: digest.to_string(),
+            correct_at: chrono::Utc::now(),
+        }
+    }
+}