Merge lp:~andrea.corbellini/lazr.restful/fix-375353 into lp:lazr.restful

[Andrea Corbellini]

[Francis J. Lacoste (flacoste)]

Hi Andrea,

First of all, let me thank you for your prompt initiative in tackling that bug and going through the paperwork to become a Canonical community contributor.

Like we discussed on IRC, it's usually a good idea to have a chat about your strategy to fix the bug with another LP developer.

The approach you took here isn't really appropriate since it would affect all methods invocation (and not only when invoked through the web service). This means that internal calls to the method would also be cached. And since this is a global cache that don't take into account parameters passed, it's really something we want to do.

So for this problem, what we really want is a webservice annotation. These are
defined in lazr.restful.declarations. The annotation should simply do error
checking on the annotation parameters and context of usage. And then stick the
caching duration in the annotation data structure.

In the BaseResourceOperationAdapter, you can then use that information to set
Cache-control header on the request response. That will leave caching to the
client which is more efficient overall (it doesn't use server resources, will
save on bandwith. Since parameters are encoded in the URL, that's also fine.)

Only GET operation should be thus cacheable. (So it should be an error to use
cache_for() in conjunction with annotation others than
export_as_read_operation.

One last item, all branches to be merged should have proper tests. In this
case, I suggest you look at src/lazr/restful/docs/webservice-declarations.txt
That's where the existing annotations are documented and tested. This should
give you a starting idea.

Don't hesitate to contact me on IRC if you need more information or encounter
any problem.

Again, thanks a lot for your initiative.

review: Needs Resubmitting

=== added file 'src/lazr/restful/methodcache.py'
--- src/lazr/restful/methodcache.py	1970-01-01 00:00:00 +0000
+++ src/lazr/restful/methodcache.py	2009-05-12 15:32:08 +0000
@@ -0,0 +1,45 @@
+# Copyright 2008 Canonical Ltd.  All rights reserved.
+
+"""Cache the results of calls to methods."""
+
+__metaclass__ = type
+__all__ = [
+    'cache_results'
+    ]
+
+from time import time
+from types import FunctionType
+
+class CachedMethod:
+    """Helper class for ``cache_result``."""
+
+    def call(*args, **kwargs):
+        now = time()
+        last_execution = self.last_execution
+        if (last_execution > 0) and (now - last_execution <= self.duration):
+            return self.cached_result
+        else:
+            result = self.cached_result = self.method(*args, **kwargs)
+            return result
+
+
+class cache_result:
+    """Cache the result of a function for the specified seconds."""
+
+    last_execution = -1
+
+    def __init__(self, duration):
+        self.duration = duration
+
+    def __call__(self, method):
+        self.method = method
+
+        call = CachedMethod().call
+        funct = FunctionType(call.func_code,
+                             call.func_globals,
+                             call.func_name,
+                             call.func_defaults,
+                             call.func_closure)
+
+        funct.func_globals['self'] = self
+        return funct