When building a highly scalable website, one of the most important tools available is caching. While there are certainly times where you don’t want to cache a method, I’ve found that the I’m even starting to carve through my alloted free App Engine memcache quota.
I’ve used a variety of memcache utilities, and have never quite been pleased with any of them. I figured that I just needed to write my own, both for the enjoyment of meta-programming, and just so that I’d be intimately familiar with the decisions behind it.
One of the biggest potential gotchas lays with the need to convert arguments for the method into a string. For instance, while you might be tempted to simply use a Profile entity as an argument for a memoize handler, it would look like this after being converted to a string:
<model.user.Profile object at 0x92fbfec>
If you later call the same method with the exact same entity, your memcache key would now look like this:
<model.user.Profile object at 0x92f9aac>
And then your memcache.get() call wouldn’t find a match for the new key.
Of course, this is elementary to anyone who has dived into Python, but the memcache utilities I’ve used have not done a good job of being strict about just not working if you give it something that you shouldn’t. They try to make a guess as to what you’d like to do, or worse, just silently do what they’re told without throwing an exception.
I like my utilities to be more of the prescriptive whistle-blowing variety, so today I wrote a memoize utility that does indeed barf in your face if you give it an argument whose type it does not strictly approve. It also allows for some kwargs like ‘force_run’ that override the caching behavior.
Licensed under Apache 2.0. Repo at http://github.com/jamslevy/gae_memoize/tree/master
import logging
import os
from google.appengine.api import memcache
ACTIVE_ON_DEV_SERVER = False
def memoize(time=1000000, force_cache=False):
"""Decorator to memoize functions using memcache.
Optional Args:
time - duration before cache is refreshed
force_cache - forces caching on dev_server (useful for APIs, etc.)
force_run - forces fxn to run and cache to refresh
Usage:
@memoize(86400)
def updateAllEntities(key_name, params, force_run=False):
entity = Model.get_by_key_name(key_name)
for param in params.items():
setattr(entity, param.key(), param.value())
db.put(entity)
"""
def decorator(fxn):
def wrapper(*args, **kwargs):
approved_args=['Link', 'Key', 'str', 'unicode', 'int','float', 'bool']
arg_string = ""
for arg in args:
if type(arg).__name__ in approved_args:
arg_string += str( arg )
else: raise UnsupportedArgumentError(arg)
for kwarg in kwargs.items():
if type(kwarg[1]).__name__ in approved_args:
arg_string += str( kwarg[1] )
else: raise UnsupportedArgumentError(arg)
key = fxn.__name__ + arg_string
logging.debug('caching key: %s' % key)
data = memcache.get(key)
if Debug(): # on dev server
if not ACTIVE_ON_DEV_SERVER:
return fxn(*args, **kwargs)
if kwargs.get('force_run'):
logging.info("forced execution of %s" % fxn.__name__)
elif data:
if data.__class__ == NoneVal:
data = None
return data
data = fxn(*args, **kwargs)
if data is None: data = NoneVal()
memcache.set(key, data, time)
return data
return wrapper
return decorator
""" Util Methods """
class UnsupportedArgumentError(Exception):
''' An unsupported argument has been passed to Memoize fxn '''
def __init__(self, value):
self.arg = value
def __str__(self):
return repr(type(self.arg).__name__ + " is not a supported arg type")
def Debug():
'''return True if script is running in the development envionment'''
return 'Development' in os.environ['SERVER_SOFTWARE']
""" Singleton Classes """
class NoneVal():
''' A replacement for None, so a memoized fxn can return a None val
without making the Memoize fxn assume that the "None" means there
isn't a cached value '''
pass