salt.cache: allow cache.store() to set expires per key

mattp- · mattp- · commit fac04fccb3e6 · 2025-05-19T16:28:55.000-04:00
rather than force a cache.cache() interface and a uniform expiry across
the cache, we add a more common per store() expiry that can also be used
instead or in addition to the original cache-wide expiry.
diff --git a/salt/cache/__init__.py b/salt/cache/__init__.py
@@ -4,6 +4,7 @@
 .. versionadded:: 2016.11.0
 """
 
+import datetime
 import logging
 import time
 
@@ -119,7 +120,7 @@ def cache(self, bank, key, fun, loop_fun=None, **kwargs):
 
         return data
 
-    def store(self, bank, key, data):
+    def store(self, bank, key, data, expires=None):
         """
         Store data using the specified module
 
@@ -136,12 +137,26 @@ def store(self, bank, key, data):
             The data which will be stored in the cache. This data should be
             in a format which can be serialized by msgpack.
 
-        :raises SaltCacheError:
+        :param expires:
+            how many seconds from now the data should be considered stale.
+
+         :raises SaltCacheError:
             Raises an exception if cache driver detected an error accessing data
             in the cache backend (auth, permissions, etc).
         """
         fun = f"{self.driver}.store"
-        return self.modules[fun](bank, key, data, **self._kwargs)
+        try:
+            return self.modules[fun](bank, key, data, expires=expires, **self._kwargs)
+        except TypeError:
+            # if the backing store doesnt natively support expiry, we handle it as a fallback
+            if expires:
+                expires_at = datetime.datetime.now().astimezone() + datetime.timedelta(
+                    seconds=expires
+                )
+                expires_at = int(expires_at.timestamp())
+            return self.modules[fun](
+                bank, key, {"data": data, "_expires": expires_at}, **self._kwargs
+            )
 
     def fetch(self, bank, key):
         """
@@ -165,7 +180,17 @@ def fetch(self, bank, key):
             in the cache backend (auth, permissions, etc).
         """
         fun = f"{self.driver}.fetch"
-        return self.modules[fun](bank, key, **self._kwargs)
+        ret = self.modules[fun](bank, key, **self._kwargs)
+
+        # handle fallback if necessary
+        if isinstance(ret, dict) and set(ret.keys()) == {"data", "_expires"}:
+            now = datetime.datetime.now().astimezone()
+            if ret["_expires"] > now:
+                return ret["data"]
+            else:
+                return {}
+        else:
+            return ret
 
     def updated(self, bank, key):
         """
@@ -309,19 +334,21 @@ def fetch(self, bank, key):
         now = time.time()
         record = self.storage.pop((bank, key), None)
         # Have a cached value for the key
-        if record is not None and record[0] + self.expire >= now:
-            if self.debug:
-                self.hit += 1
-                log.debug(
-                    "MemCache stats (call/hit/rate): %s/%s/%s",
-                    self.call,
-                    self.hit,
-                    float(self.hit) / self.call,
-                )
-            # update atime and return
-            record[0] = now
-            self.storage[(bank, key)] = record
-            return record[1]
+        if record is not None:
+            (created_at, expires, data) = record
+            if (created_at + (expires or self.expire)) >= now:
+                if self.debug:
+                    self.hit += 1
+                    log.debug(
+                        "MemCache stats (call/hit/rate): %s/%s/%s",
+                        self.call,
+                        self.hit,
+                        float(self.hit) / self.call,
+                    )
+                # update atime and return
+                record[0] = now
+                self.storage[(bank, key)] = record
+                return record[1]
 
         # Have no value for the key or value is expired
         data = super().fetch(bank, key)
@@ -333,15 +360,15 @@ def fetch(self, bank, key):
         self.storage[(bank, key)] = [now, data]
         return data
 
-    def store(self, bank, key, data):
+    def store(self, bank, key, data, expires=None):
         self.storage.pop((bank, key), None)
-        super().store(bank, key, data)
+        super().store(bank, key, data, expires)
         if len(self.storage) >= self.max:
             if self.cleanup:
                 MemCache.__cleanup(self.expire)
             if len(self.storage) >= self.max:
                 self.storage.popitem(last=False)
-        self.storage[(bank, key)] = [time.time(), data]
+        self.storage[(bank, key)] = [time.time(), expires, data]
 
     def flush(self, bank, key=None):
         if key is None:
