Oliver’s Place

# define application servers
upstream backend
{
  server 127.0.0.1:8080 weight=1;
}
 
server
{
  listen 80;
  server_name domain.com;
  access_log /var/log/nginx/domain.com.log;
 
  location /
  {
    # we never cache post requests
    if ($request_method = POST)
    {
      proxy_pass http://backend;
      break;
    }
 
    # extract cache key args and compute cache key
    if ($http_cookie ~* "pv=([^;]+)(?:;|$)")
    {
      set $page_version $1;
    }
    set $memcached_key $request_uri&pv=$page_version;
 
    # Check if local memcached server can answer this request
    default_type text/html;
    memcached_pass 127.0.0.1:11211;
 
    # Send to app. server if Memcached could not answer the request
    error_page 404 = @cache_miss;
  }
 
  location @cache_miss
  {
    proxy_pass http://backend;
  }
}

@cache_page_nginx(3600*6, compute_common_page_version)
def index(request):
  return render_to_response('index.html')
 
def compute_common_page_version(request):
  '''This method is called by the nginx_cache decorator
  The method is supposed to return some value that can be used to distinguish
  different cached versions of the same page. For now it is sufficient to differentiate
  between authenticated and anonymous users'''
  if request.user and request.user.is_authenticated():
    return 1
  return 0

from django.utils.decorators import decorator_from_middleware
from django.conf import settings
from django.core.cache import cache
from django.utils.encoding import smart_unicode, smart_str
from utils import kdebug
 
try:
    import cmemcache as memcache
except ImportError:
    try:
        import memcache
    except:
        raise InvalidCacheBackendError("Memcached cache backend requires either the 'memcache' or 'cmemcache' library")
 
class UpdateCacheMiddleware(object):
  """
  Updates memcached with the response of the request. It is of _paramount_
  importance that the generated cache_key matches exactly the key generated
  by your web to lookup the page from the cache.
 
  This class talks to memcached, bypassing Djangos cache backend because
  it is only meant to talk to memcached and nothing else.
 
  Must the first piece of middleware in settings.MIDDLEWARE_CLASSES so
  that it'll get called last during the response phase.
  """
  def __init__(self, cache_timeout, page_version_method):
    '''timeout - is the timeout in seconds after which the cached response expires in memcached
    page_version_method - is called during response processing and must return an arbitrary value
    that can be used to distinguish different cached versions of the same page '''
    self.cache_timeout = cache_timeout
    self.page_version_method = page_version_method
    self.cache = memcache.Client(settings.NGINX_MEMCACHED_SERVERS)
    self.cookie_name = 'pv'
 
  def process_response(self, request, response):
    """Sets the cache, if needed."""
    if not settings.NGINX_MEMCACHED_ENABLE or request.method != 'GET' or not response.status_code == 200:
      # because of interactions between this middleware and the
      # HTTPMiddleware, which throws the body of a HEAD-request
      # away before this middleware gets a chance to cache it.
      return response
 
    self.cache_response(request, response)
    return response
 
  def cache_response(self, request, response):
    '''Manually insertion of cached version of page into the cache'''
    # retrieve page version
    pv = self.page_version_method(request)
 
    # compute key that's follows the same naming convention as specified in nginx configuration:
    # set $memcached_key $request_uri&sid=$session_id;
    cache_key = self.compute_cache_key_from_request(request, pv)
 
    # update cache
    self.cache.set(cache_key, response._get_content(), self.cache_timeout)
 
    # communicate the page version to the browser using cookie
    response.set_cookie(self.cookie_name, pv)
 
  def compute_cache_key_from_request(self, request, page_version):
    '''Computes the cache key for the specified page and version of the page'''
    return self.compute_cache_key(request.get_full_path(), page_version)
 
  def compute_cache_key(self, page, page_version):
    '''Computes the cache key for the specified page and version of the page'''
    return smart_str("%s&%s=%s" % (page, self.cookie_name, page_version))
 
  def invalidate_page_version_from_request(self, request, page_version):
    '''Removes the specified version of the page requested by 'request' from the cache'''
    cache_key = self.compute_cache_key_from_request(request, page_version)
    self.cache.delete(cache_key)
 
  def invalidate_page_version(self, page, page_version):
    '''Removes the specified version of the page requested by 'request' from the cache'''
    cache_key = self.compute_cache_key(request, page_version)
    self.cache.delete(cache_key)
 
# decorator
cache_page_nginx = decorator_from_middleware(UpdateCacheMiddleware)