From 4879753edfc7380e1e96d882716b60e981a4de53 Mon Sep 17 00:00:00 2001
From: Kali Kaneko <kali@leap.se>
Date: Wed, 18 Dec 2013 22:31:23 -0400
Subject: Fix memoize decorator: raise instead of storing None

With this fix, we will re-raise an exception that happens
while evaluating the callable, instead of storing None as value.
---
 src/leap/common/decorators.py | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

(limited to 'src/leap/common/decorators.py')

diff --git a/src/leap/common/decorators.py b/src/leap/common/decorators.py
index ec6171a..e708fc4 100644
--- a/src/leap/common/decorators.py
+++ b/src/leap/common/decorators.py
@@ -56,6 +56,15 @@ class _memoized(object):
         :tyoe args: tuple
         :type kwargs: dict
         """
+        def ret_or_raise(value):
+            """
+            Returns the value except if it is an exception,
+            in which case it's raised.
+            """
+            if isinstance(value, Exception):
+                raise value
+            return value
+
         if self.is_method:
             # forget about `self` as key
             key_args = args[1:]
@@ -74,15 +83,16 @@ class _memoized(object):
 
         if key in self.cache:
             logger.debug("Got value from cache...")
-            return self.cache[key]
+            value = self.cache[key]
+            return ret_or_raise(value)
         else:
             try:
                 value = self.func(*args, **kwargs)
             except Exception as exc:
                 logger.error("Exception while calling function: %r" % (exc,))
-                value = None
+                value = exc
             self.cache[key] = value
-            return value
+            return ret_or_raise(value)
 
     def __repr__(self):
         """
-- 
cgit v1.2.3


From d46207491b9c0c0fc3a79256fe00bfe3f60712a0 Mon Sep 17 00:00:00 2001
From: Kali Kaneko <kali@leap.se>
Date: Thu, 19 Dec 2013 12:49:22 -0400
Subject: add cache invalidation

---
 src/leap/common/decorators.py | 61 ++++++++++++++++++++++++++++++++++---------
 1 file changed, 49 insertions(+), 12 deletions(-)

(limited to 'src/leap/common/decorators.py')

diff --git a/src/leap/common/decorators.py b/src/leap/common/decorators.py
index e708fc4..2ef6711 100644
--- a/src/leap/common/decorators.py
+++ b/src/leap/common/decorators.py
@@ -18,6 +18,7 @@
 Useful decorators.
 """
 import collections
+import datetime
 import functools
 import logging
 
@@ -32,7 +33,13 @@ class _memoized(object):
     If called later with the same arguments, the cached value is returned
     (not reevaluated).
     """
-    def __init__(self, func, ignore_kwargs=None, is_method=False):
+
+    # cache invalidation time, in seconds
+    CACHE_INVALIDATION_DELTA = 1800
+
+    def __init__(self, func, ignore_kwargs=None, is_method=False,
+                 invalidation=None):
+
         """
         :param ignore_kwargs: If True, ignore all kwargs.
                               If tuple, ignore those kwargs.
@@ -45,9 +52,13 @@ class _memoized(object):
         self.is_method = is_method
         self.func = func
 
+        if invalidation:
+            self.CACHE_INVALIDATION_DELTA = invalidation
+
         # TODO should put bounds to the cache dict so we do not
         # consume a huge amount of memory.
         self.cache = {}
+        self.cache_ts = {}
 
     def __call__(self, *args, **kwargs):
         """
@@ -68,6 +79,9 @@ class _memoized(object):
         if self.is_method:
             # forget about `self` as key
             key_args = args[1:]
+        else:
+            key_args = args
+
         if self.ignore_kwargs is True:
             key = key_args
         else:
@@ -82,17 +96,40 @@ class _memoized(object):
             return self.func(*args, **kwargs)
 
         if key in self.cache:
-            logger.debug("Got value from cache...")
-            value = self.cache[key]
-            return ret_or_raise(value)
-        else:
-            try:
-                value = self.func(*args, **kwargs)
-            except Exception as exc:
-                logger.error("Exception while calling function: %r" % (exc,))
-                value = exc
-            self.cache[key] = value
-            return ret_or_raise(value)
+            if self._is_cache_still_valid(key):
+                value = self.cache[key]
+                logger.debug("Got value from cache...")
+                return ret_or_raise(value)
+            else:
+                logger.debug("Cache is invalid, evaluating again...")
+
+        # no cache, or cache invalid
+        try:
+            value = self.func(*args, **kwargs)
+        except Exception as exc:
+            logger.error("Exception while calling function: %r" % (exc,))
+            value = exc
+        self.cache[key] = value
+        self.cache_ts[key] = datetime.datetime.now()
+        return ret_or_raise(value)
+
+    def _is_cache_still_valid(self, key, now=datetime.datetime.now):
+        """
+        Returns True if the cache value is still valid, False otherwise.
+
+        For now, this happen if less than CACHE_INVALIDATION_DELTA seconds
+        have passed from the time in which we recorded the cached value.
+
+        :param key: the key to lookup in the cache
+        :type key: hashable
+        :param now: a callable that returns a datetime object. override
+                    for dependency injection during testing.
+        :type now: callable
+        :rtype: bool
+        """
+        cached_ts = self.cache_ts[key]
+        delta = datetime.timedelta(seconds=self.CACHE_INVALIDATION_DELTA)
+        return (now() - cached_ts) < delta
 
     def __repr__(self):
         """
-- 
cgit v1.2.3