<filter>
  <filter-name>memcached</filter-name>
  <filter-class>com.banshee.servlet.MemcachedFilter</filter-class>
</filter>
 
<!-- memcached filter -->
<filter-mapping>
  <filter-name>memcached</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>
 
 
<filter-mapping>
  <filter-name>charEncodingFilter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>
 
<filter-mapping>
  <filter-name>sitemesh</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

class FooController
{
  def index =
  {
    if(!SecurityUtils.subject.principal)      // store response only for anonymous users (using Shiro plugin)
    {
      response.setHeader(MemcachedFilter.MEMCACHED_FILTER_X_CACHE_KEY, ConfigurationHolder.config.app_prefix + (request.forwardURI - request.contextPath))
      response.setHeader(MemcachedFilter.MEMCACHED_FILTER_X_CACHE_TIMEOUT, 120)         // cache for two minutes
    }
  }
}

class CacheFilters
{
  CacheService questionCacheService
 
  final static String MEMCACHED_USER_IS_AUTH_INDICATOR_COOKIE = 'user_id'
 
  def filters =
  {
    /** Sets or deletes a cookie that signals nginx that the current user is authenticated - not used for permission checks */
    setNginxUserIsAuthenticatedIndicator(controller: '*', action: '*')
    {
      afterView =
      {
        def cookie = request.cookies.find { it.name == MEMCACHED_USER_IS_AUTH_INDICATOR_COOKIE }
 
        // is the user authenticated (by login or cookie?)
        if(SecurityUtils.subject.principal)
        {
          // yes, set the cookie if needed
          if(!cookie)
          {
            cookie = new Cookie(MEMCACHED_USER_IS_AUTH_INDICATOR_COOKIE, User.get(SecurityUtils.subject.principal).id.toString())
            cookie.setPath(request.getContextPath())
            response.addCookie(cookie)
          }
        }
 
        else
        {
          // delete the cookie if necessary
          if(cookie)
          {
            cookie.setMaxAge(0)
            cookie.setPath(request.getContextPath())
            response.addCookie(cookie)
          }
        }
      }
    }
  }
}

upstream tomcats
{
  server 127.0.0.1:8080 weight=1;
}
 
server
{
  listen 80;
  server_name example.com;
  access_log /var/log/nginx/example.log;
 
  include ua_ban_list.conf;
 
  proxy_set_header Host $http_host;
  proxy_set_header X-Real-IP $remote_addr;
  proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 
  default_type text/html;
  charset utf-8;
 
  proxy_redirect http://tomcats/ http://example.com/;
 
  location /
  {
    # only consider GET requests for caching
    if ($request_method != GET)
    {
      proxy_pass http://tomcats;
      break;
    }
 
    # never cache auth requests
    if ($request_uri ~* (^/auth/.*$))
    {
      proxy_pass http://tomcats;
      break;
    }
 
    # detect cookies that indicate an authenticated user
    if ($http_cookie ~* "(rememberMe|user_id)")
    {
      # don't try cache lookup for authenticated user - NEVER
      proxy_pass http://tomcats;
      break;
    }
 
    # compute cache key from app prefix + request_uri
    # if they computed key does not match the key computed by the application
    # server when storing content we will get nothing but memcached misses
    # and NO speedup
    set $memcached_key example_$request_uri;
    memcached_pass memcached;
    error_page 404 = @cache_miss;
  }
 
  location @cache_miss
  {
    internal;
    proxy_pass http://tomcats;
  }
}

<a href="/topic/delete/10">Delete</a>|<a href="/topic/lock/10">Lock</a>

class MenuTagLib
{
  static namespace = 'mx'
 
  /** The toolbar container */
  def toolbar =
  { attrs, body ->
    def separator = attrs.separator ?: '|'
 
    // we'll be using this to keep track of our items
    def menuItems = []
    this.pageScope.menuItems = menuItems
 
    // this will execute the body, so that the items are appended obviously,
    // anything other than the item tags will not render correctly.
    body()
 
    // render every item and add a separator except for the last item 
    menuItems.eachWithIndex
    { item, index ->
      out << item
      if(index < menuItems.size() - 1)
        out << separator
    }
  }
 
  /** A toolbar item */
  def item =
  { attrs, body ->
    def itemContent = body().trim()
    if(itemContent) // only add the item if rendering evaluated to non-empty string
      this.pageScope.menuItems << itemContent
  }
}

java.lang.NullPointerException
	at $Proxy13.createQuery(Unknown Source)
	at com.acme.PerformanceService.makePerformanceSheet(PerformanceService.groovy:38)
  ...

java.lang.NullPointerException
	at org.hibernate.dialect.Dialect$3.getReturnType(Dialect.java:125)
	at org.hibernate.hql.ast.util.SessionFactoryHelper.findFunctionReturnType(SessionFactoryHelper.java:405)
	at org.hibernate.hql.ast.tree.AggregateNode.getDataType(AggregateNode.java:44)
	at org.hibernate.hql.ast.tree.SelectClause.initializeExplicitSelectClause(SelectClause.java:165)
	at org.hibernate.hql.ast.HqlSqlWalker.useSelectClause(HqlSqlWalker.java:727)
	at org.hibernate.hql.ast.HqlSqlWalker.processQuery(HqlSqlWalker.java:551)
	at org.hibernate.hql.antlr.HqlSqlBaseWalker.query(HqlSqlBaseWalker.java:645)
	at org.hibernate.hql.antlr.HqlSqlBaseWalker.selectStatement(HqlSqlBaseWalker.java:281)
	at org.hibernate.hql.antlr.HqlSqlBaseWalker.statement(HqlSqlBaseWalker.java:229)
	at org.hibernate.hql.ast.QueryTranslatorImpl.analyze(QueryTranslatorImpl.java:251)
	at org.hibernate.hql.ast.QueryTranslatorImpl.doCompile(QueryTranslatorImpl.java:183)
	at org.hibernate.hql.ast.QueryTranslatorImpl.compile(QueryTranslatorImpl.java:134)
	at org.hibernate.engine.query.HQLQueryPlan.<init>(HQLQueryPlan.java:101)
	at org.hibernate.engine.query.HQLQueryPlan.<init>(HQLQueryPlan.java:80)
	at org.hibernate.engine.query.QueryPlanCache.getHQLQueryPlan(QueryPlanCache.java:94)
	at org.hibernate.impl.AbstractSessionImpl.getHQLQueryPlan(AbstractSessionImpl.java:156)
	at org.hibernate.impl.AbstractSessionImpl.createQuery(AbstractSessionImpl.java:135)
  ...

org.hibernate.hql.ast.tree.AggregateNode.getDataType

beans =
{
  memcachedClient(MemcachedClient, 
    net.spy.memcached.AddrUtil.getAddresses(
      ConfigurationHolder.config.memcached_servers))
  { bean ->
    bean.scope = 'singleton' 
  }
}

environments
{
  development
  {
    memcached_servers = "192.168.230.2:11211"
  }
 
  production
  {
    memcached_servers = "localhost:11211"
  }
}

def renderElementUpdateResponse(elements)
{
  def rendered_elements = [:]
 
  elements.eachWithIndex
  { k, v, i ->
    rendered_elements[k] = [:]
    rendered_elements[k]['mode'] = v['mode']
 
    // if content is a Map, feed it into g.render - using the key as template name and the value as model
    if(v['content'] instanceof java.util.LinkedHashMap)
      rendered_elements[k]['content'] = g.render(template: v['content'].keySet().toArray()[0], model: v['content'].values().toArray()[0])
    else
      rendered_elements[k]['content'] = v['content']
  }
 
  def tmp = ['updates': rendered_elements]
  render tmp as JSON
}

function applyElementUpdates(transport)
{
  var updates;
 
  if (transport.updates)
  {
    updates = transport.updates;
    var scripts = new Array()  // need to queue initializers until all updates are done
 
    for(target in updates)
    {
      if(updates[target]['mode'] == 'execute')
      {
        code = updates[target]['content']
        scripts.push(code)
        continue
      }
 
      var targetNode = $(target);
      var newContent = updates[target]['content'];
      var oldContent = targetNode.html();
 
      switch(updates[target]['mode'])
      {
        case 'replace':
          targetNode.html(newContent);
          break;
        case 'insert':
          targetNode.html(newContent + oldContent);
          break;
        case 'append':
          targetNode.html(oldContent + newContent);
          break;
      }
    }
 
    // now run initializers
    for(i in scripts)
    {
      code = scripts[i]
      eval(code)
    }
  }
}

<%@ page contentType="text/html;charset=UTF-8" %>
<html>
  <head>
    <g:javascript src="jquery-1.3.2.js" />
    <g:javascript src="applyElementUpdates.js" />
 
    <script type="text/javascript">
    $(document).ready(function()
    {
      $('#btnClickMe').click(function()
      {
        $.ajax(
        {
          url: '${createLink(controller: 'test', action: 'update')}',
          type: "POST",
          dataType: "json",
          cache: false,
          async: true,
          success: function(data, status)
          {
            applyElementUpdates(data)
          }
        })
      })
    });
    </script>
  </head>
  <body>
  <input type="button" id="btnClickMe" value="Click me"/>
  <br/><br/>
  <div id="div1"></div>
  <div id="div2"></div>
  </body>
</html>

import grails.converters.JSON
 
class TestController extends BaseController
{
  def index =
  {
  }
 
  def update =
  {
    def model = [a: 1, b: 2]
 
    // Note: renderElementUpdateResponse is supposed to be implemented in BaseController
    return renderElementUpdateResponse(
    [
      '#div1'   : [ 'mode': 'replace', 'content' : [ 'fragment1': model ] ],
      '#div2'   : [ 'mode': 'append', 'content'  : [ 'fragment2': model ] ],
      '__init__': [ 'mode': 'execute', 'content' : 'alert("The page has been updated")' ]
    ])
  }
}

 '#div1': [ 'mode': 'replace', 'content' : [ 'fragment1': model ] ]

 '#div2': [ 'mode': 'append', 'content' : [ 'fragment2': model ] ]

 '__init__': [ 'mode': 'execute', 'content' : 'alert("The page has been updated")' ]

<span>Value of A is ${a}</span>

<span>Value of B is ${b}</span><br/>

uiperformance.determineVersion = { -> "git rev-list --max-count=1 HEAD".execute().text.trim() }

{% load mediamerge %}
 
{% mediamerge merged/standard 1 scripts/jquery-1.2.6.min.js scripts/jquery.cookie.js scripts/superfish.js scripts/supersubs.js scripts/shared.js %}

<script src="http://static.example.com/merged/standard.js?1" type="text/javascript"><!--mce:0--></script>

MEDIAMERGE_ENABLE_MEMCACHED = True
MEDIAMERGE_MEMCACHED_URI_PREFIX = "mmerge_"
MEMCACHED_SERVERS = [ 'localhost:11211' ]

server
{
	listen 80;
	server_name static.example.com;
	expires 24h;
 
	# mediamerge
	location /merged/
	{
		set $memcached_key mmerge_$scheme://$server_name$request_uri;
		memcached_pass 127.0.0.1:11211;
	}
 
	location /
	{
		root /var/www/example_static;
	}
}

import os, re
import logging
from os import path
import cStringIO as StringIO
from django.template import Library, Node, TemplateSyntaxError
from django.conf import settings
 
logger = logging.getLogger('mediamerge')
mc = None
register = Library()
 
class JSMergeNode(Node):
	def __init__(self, js_name, js_ver, js_files):
		self.js_name = '%s.js' % js_name
		self.js_ver = js_ver
		self.js_files = js_files
		self.merge_filename = path.normpath(path.join(settings.MEDIA_ROOT, self.js_name))
 
		# make sure that the target directory exists
		if not settings.MEDIAMERGE_ENABLE_MEMCACHED and not path.exists(path.dirname(self.merge_filename)):
			os.makedirs(path.dirname(self.merge_filename))
 
	def merge_files(self, merge_file):
		# join all input files into a single output file
		for js in self.js_files:
			jspath = path.normpath(path.join(settings.MEDIA_ROOT, js))
			if not path.isfile(jspath):
				continue
			self.merge_js(js, jspath, merge_file)
 
	def render(self, context):
		'''Implementation of the render method of the tag'''
		if settings.MEDIAMERGE_ENABLE_MEMCACHED:
			return self.render_memcached(context)
		else:
			return self.render_file(context)
 
	def render_passthrough(self, context):
		result = ""
		for js in self.js_files:
			if settings.MEDIA_URL[-1] == '/':
				result += '<script type="text/javascript" src="%s%s"></script>\n' % (settings.MEDIA_URL, js)
			else:
				result += '<script type="text/javascript" src="%s/%s"></script>\n' % (settings.MEDIA_URL, js)
		return result
 
	def render_memcached(self, context):
		'''Memcached based render method - merged output directly stored in memcache - where nginx will pick it up based on the rquest uri) without using a temp file'''
		import memcache
		key = settings.MEDIAMERGE_MEMCACHED_URI_PREFIX + str(self.compute_media_url())
 
		global mc
		if not mc:
			mc = memcache.Client(settings.MEMCACHED_SERVERS, debug=0)
 
		if not mc.get(key):
			merge_file = StringIO.StringIO()
			self.merge_files(merge_file)
			contents = merge_file.getvalue()
			mc.set(key, contents, 3600)
			logger.info('Setting memcached value for for resource %s - key %s' % (self.js_name, key))
 
		else:
			logger.debug('Merge key %s already exists in memcached for resource %s' % (key, self.js_name))
 
		return self.js_tag()
 
	def render_file(self, context):
		'''File based render method - merged output directly stored in the file specified with the tag - relative to settings.MEDIA_ROOT'''
		if not path.exists(self.merge_filename) or not self.is_merge_updated():
			logger.debug('Trying to open output file %s for resource %s' % (self.merge_filename, self.js_name))
			merge_file = open(self.merge_filename, 'wb')
			self.merge_files(merge_file)
			merge_file.close()
		else:
			logger.debug('Merge file %s already exists for resource %s' % (self.merge_filename, self.js_name))
 
		return self.js_tag()
 
	def is_merge_updated(self):
		if settings.MEDIAMERGE_DISABLE_MERGE_UPDATES:
			return True
 
		""" compares modification time of all js with merged js """
		last_mtime = 0 # last modification time of a js file
		for js in self.js_files:
			jspath = path.normpath(path.join(settings.MEDIA_ROOT, js))
			jsstat = os.stat(jspath)
			mtime = jsstat[-2]
			if last_mtime < mtime:
				last_mtime = mtime
		merge_mtime = os.stat(self.merge_filename)[-2]
		return merge_mtime > last_mtime
 
	def merge_js(self, jsname, jspath, fd):
		""" do merging and compressing of javascript """
		logger.debug('Merging file %s for resource %s' % (jsname, self.js_name))
 
		jsfile = open(jspath, "rb")
		jscontent = jsfile.read()
		fd.write('/* -- %s -- */\n\n' % jsname)
		fd.write(jscontent)
		fd.write("\n\n\n")
 
	def compute_media_url(self):
		# detect if MEDIA_URL ends with a slash
		if settings.MEDIA_URL[-1] == '/':
			js_url = '%s%s' % (settings.MEDIA_URL, self.js_name, self.js_ver)
		else:
			js_url = '%s/%s?%d' % (settings.MEDIA_URL, self.js_name, self.js_ver)
 
		return js_url
 
	def js_tag(self):
		""" write js tag for merged file inclusion """
 
		return '<script type="text/javascript" src="%s"></script>' % self.compute_media_url()
 
 
def do_jsmerge(parser, token):
	"""
	This will merge javascript files in only one compressed javascript.
 
	Usage::
 
		{% load mediamerge %}
		{% mediamerge <output_js_file> <output_version_integer> [jsfile1] [jsfile2] .. %}
 
	Example::
 
		{% load mediamerge %}
		{% mediamerge mediamergefile 1  js/file1.js js/file2.js js/file3.js %}
 
	This will create (if not exists) a /media/mediamergefile.js with three files merged. The HTML output for this will be::
 
		<script type="text/javascript" src="/media/mediamergefile.js"></script>
	"""
	tokens = token.contents.split()
	if len(tokens) < 3:
		raise TemplateSyntaxError(u"'%r' tag requires at least 1 arguments." % tokens[0])
	return JSMergeNode(tokens[1], int(tokens[2]), tokens[3:])
 
 
register.tag('mediamerge', do_jsmerge)

# 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)