Oliver's Place http://weichhold.com Thu, 12 Aug 2010 18:13:53 +0000 en hourly 1 http://wordpress.org/?v=3.0.1 Using Mercurial over SSH with Private Key in TeamCity CI http://feedproxy.google.com/~r/olivers_place/~3/n2k_00hvyew/ http://weichhold.com/2010/08/12/using-mercurial-over-ssh-with-private-key-in-teamcity-ci/#comments Thu, 12 Aug 2010 15:52:56 +0000 oliver http://weichhold.com/?p=161 Due to the much better Visual Studio and Windows integration of Mercurial I’ve recently switched from Git to Mercurial for my .Net based projects. After setting up a Windows Server 2008 R2 instance on my VMWare vSphere Box I’ve switched from Hudson to TeamCity for Continuous Integration and I’m pretty satisfied with the outcome. I can finally handle both Java and .Net Projects on a single CI Server.

There was one issue that was causing me a major headache during the setup phase and that was getting Mercurial talk to my private repository server over SSH using private key authentication from within TeamCity’s Windows Service running under the SYSTEM account (I’d rather have it run under a non-privileged user but that doesn’t seem to be supported).

The first problem was getting Mercurial to use Putty’s plink.exe while running under the system account. Normally you would just create a file named mercurial.ini in the user’s home directory containing something like this:

?View Code INI
[ui]
ssh = "C:\Program Files\putty\plink.exe" -i "c:\your.ppk"

But where do you put this file in the case of the system account? Some Googling on that matter turned out that it should go to \System32\config\systemprofile. I’ve tried that to no avail. Mercurial would still try to invoke ssh.exe which is obviously nowhere to be found on a Windows box. I realized that the Mercurial Executable is 32-Bit which meant that the home directory of the SYSTEM account had to be located somewhere under \SysWoW64 and indeed there is a \SysWoW64\config\systemprofile directory. After moving my mercurial.ini to that directory the “Test Connection” button in TeamCity would *drumroll* … HANG!

The reason for this behavior was that plink.exe prompted the user to accept the new ssh host key – in an invisible shell window. To overcome this hurdle I shutdown the TeamCity Web Service and opened a new shell window running under the SYSTEM Account using the psExec Utility by Mark Russinovich:

?View Code SHELL
psexec.exe -s cmd.exe

Now that I had a shell running under the system account I could connect to my server and accept the host key:

?View Code SHELL
plink 192.168.230.1

Low and behold clicking the “Test Connection” button in TeamCity would now give me a different error:

?View Code SHELL
"C:\Program Files (x86)\Mercurial\hg.exe" identify ssh://git@192.168.230.1/usr/local/hg/testproject' command failed.
stderr: abort: no suitable response from remote hg!
 
stdout: remote: abort: There is no Mercurial repository here (.hg not found)!

Fiddling around with the settings for another hour turned out that there was a problem with my SSH Url in TeamCity: ssh://git@192.168.230.1/usr/local/hg/testproject

  1. The ssh URL contained the user name
  2. The path needs to contain a second / at the beginning otherwise the server will see it as “usr/local/hg/testproject”
  3. The user name must not be part of the SSH Url but needs be entered in Teamcity’s “User name:” field under “Authorization Settings”

After changing the SSH Url to: ssh://192.168.230.1//usr/local/hg/testproject (please note the double slash after the host), I could finally connect, pull the sources and build my project.

Please keep in mind that your private key may not be protected by a passphrase!


]]> http://weichhold.com/2010/08/12/using-mercurial-over-ssh-with-private-key-in-teamcity-ci/feed/ 0 http://weichhold.com/2010/08/12/using-mercurial-over-ssh-with-private-key-in-teamcity-ci/ High performance Grails with memcached http://feedproxy.google.com/~r/olivers_place/~3/f-FKMz62mOA/ http://weichhold.com/2010/03/04/high-performance-grails-with-memcached/#comments Thu, 04 Mar 2010 21:28:24 +0000 oliver http://weichhold.com/?p=148 This article is the second one in my article series about fast loading web pages. The first article dealt with the Django Framework while this one is about Grails which I have recently elected as my preferred rapid web application framework. Ever since I switched from Django to Grails there was one issue that bothered me and that was the loss of the ability to serve complete pre-rendered pages from a distributed cache to the enduser while bypassing the application server.

The solution described in this article is in use on the production servers powering mmogle.com where it ensures page response times below 100ms for cached content.

Let me summarize the concept for readers not familiar with my first article: The goal we want to achieve is to greatly decrease the load on the application server (container) by storing the raw HTML output of rendered pages in a (distributed-) cache to be picked up by a Frontend Web Server without even bothering the application server behind it for the current request. Since we would need stuff like Edge Side Includes (ESI) for dealing with personalized pages, we are going limit ourselves to anonymous users.

This picture below shows the server setup:

nginx-memcached

Nginx will act as frontend web server. This is where all requests will initially arrive. Requests for static resources will always be handled by nginx. Dynamic requests will be scrutinized and once it is determined that a request could be cached, a cache key is computed based on request URI, cookies etc. Nginx will then proceed with querying memcached if one of the application servers has deposited content under that key. If the answer is positive the response from memcached is directly returned to the client – the application servers are bypassed. Perhaps it is worth noting that the application server (tomcat) is only responsible for storing the content, whereas nginx – acting as frontend server – is responsible for retrieving it. This decoupling is what sets this technique apart from the Grails Cache Filter Plugin which both stores and retrieves cached content.

Let’s continue with the actual implementation. When I decided to port the technique I described in the aforementioned article from Python/Django to Groovy/Grails, I thought it was going to be a very easy task. All that’s needed is to grab the rendered page contents within a Grails afterView Filter, put it into memcached and be done with it, right? Wrong! Imagine my surprise when I noticed the rendered output never had a layout applied. After lots of trying I gave up, realising that there is simply no way to get my hands on the complete HTML (emphasis on complete) for a rendered Grails page from within the application itself. The reason for this is Grails layouts are based on Sitemesh which is implemented as a ServletFilter. Grails applies the Layout to pages through its GrailsPageFilter ServletFilter which is executed further down in the pipeline after any Grails Filters.

That left me with only one option: a custom ServletFilter that executes before GrailsPageFilter. So I checked out the source of the Grails Cache Filter Plugin, stripped it off anything not necessary for our purpose and born was MemcachedFilter. You can download the source here.

MemcachedFilter is written in Groovy and it needs to be configured to execute before GrailsPageFilter. That means that it’s filter mapping element must appear before the filter mapping for GrailsPageFilter in web.xml. Here’s a sample web.xml snippet:

?View Code XML
<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>

MemcachedFilter has a dependency on a bean named “memcachedClient”. Please refer to this article for configuration instructions.

Now that the filter is configured and active we actually want to put it to use – which is quite easy. The filter scans all Responses it encounters for the presence of two special headers: “X-Memcached-Filter-Cache-Key” and “X-Memcached-Filter-Cache-Timeout” (the latter is optional). If the “X-Memcached-Filter-Cache-Key” is detected the filter will store the response content in memcached using the header value as key. The expiration timeout will be either a default value or the value of the “X-Memcached-Filter-Cache-Timeout” header. It’s that simple. Here’s a usage example:

?View Code GROOVY
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
    }
  }
}

This will store the response content for FooController’s ‘index’ action in memcached for two minutes using the context relative request URI as cache key as long as the requesting user is not logged in. It is of paramount importance that you never ever do this for authenticated users or bad things may happen. You don’t want John Doe to access information intended for the boss, only because the boss happened to be the first user accessing a certain page, do you? To make sure that our Frontend server will try fetch content from the cache for authenticated users we need a way for it to tell if a request is from an anonymous or authenticated user. To do this I wrote a simple Grails Filter that ensures that authenticated users are tagged with a cookie:

?View Code GROOVY
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)
          }
        }
      }
    }
  }
}

Rest assured that the sole purpose of the cookie is to signal the frontend server that a user is authenticated in order to disable any cache retrieval attempts. No security checks are ever performed against the cookie.

Now that we’ve taken care of storing the content, someone has to retrieve it. As already mentioned we are using Nginx as Frontend server. I’m a big fan of it because of its small footprint, great performance and integrated support for memcached. Below is a Nginx virtual host configuration that implements the remaining bits and pieces:

?View Code APACHE
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;
  }
}

Please pay special attention to the line where the cache key is computed. A key prefix “example_” is used. To get the example to work you would have to add a config variable ‘app_prefix’ to Config.groovy which needs to have the value “example_”.

Finally I should point out that this approach isn’t tied to Grails applications. Basically any Java Web application could use it if someone would port the MemcachedFilter from Groovy to Java which should be a piece of cake considering that it was developed from Java Sources in the first place.

That’s it for now. I hope you enjoyed the ride.


]]> http://weichhold.com/2010/03/04/high-performance-grails-with-memcached/feed/ 0 http://weichhold.com/2010/03/04/high-performance-grails-with-memcached/ Mapping the result of a native SQL query to a Grails domain class collection http://feedproxy.google.com/~r/olivers_place/~3/ZY2idyBvs-0/ http://weichhold.com/2010/01/18/mapping-result-of-a-native-sql-query-to-grails-domain-class-collection/#comments Mon, 18 Jan 2010 20:05:27 +0000 oliver http://weichhold.com/?p=143 Today I could once again not find a proper way to express a query needed for my current Grails project in either Hibernate HQL nor the DSL based variant of Hibernate’s Criteria API.

While it is quite simple to run native SQL Queries in Grails Project using Spring’s NamedParameterJdbcTemplate I never had to actually Map the result of a native SQL back to one of my Grails Domain Classes. After a bit of fiddling around it turned out that everything becomes quite trivial once you get ahold of the Hibernate SessionFactory that is made available by Grails for each request.

Let’s pretend we have the following Grails domain class:

?View Code GROOVY
package com.acme.domain
 
class Foo
{
  String name
}

You would execute a native SQL Query that returns a List of Foo instances like this:

?View Code GROOVY
import com.acme.domain.*
 
def sessionFactory
sessionFactory = ctx.sessionFactory  // this only necessary if your are working with the Grails console/shell
def session = sessionFactory.currentSession 
 
def query = session.createSQLQuery("select f.* from Foo where f.id = :filter)) order by f.name");
query.addEntity(com.acme.domain.Foo.class);
query.setInteger("filter", 88);
query.list()*.name;


]]> http://weichhold.com/2010/01/18/mapping-result-of-a-native-sql-query-to-grails-domain-class-collection/feed/ 0 http://weichhold.com/2010/01/18/mapping-result-of-a-native-sql-query-to-grails-domain-class-collection/ A simple GSP toolbar taglib for Grails http://feedproxy.google.com/~r/olivers_place/~3/vQievfMUuZc/ http://weichhold.com/2010/01/13/a-simple-gsp-toolbar-taglib-for-grails/#comments Wed, 13 Jan 2010 15:55:26 +0000 oliver http://weichhold.com/?p=112 Did you ever had to implement a menu in Grails GSP where every link element should be seperated from its predecessor by a separator character and where some of the elements can be missing when certain conditions are not met (security etc)?

The part with the optional elements can turn the separator handling into a real mess. So today I decided to end this nonsense. The result is a tiny taglib which can be integrated into every grails project. The usage is pretty self explanatory:


<mx:toolbar separator=’|'>
  <mx:item>
    <shiro:hasPermission permission=”topic:delete”>
      <g:link controller=”topic” action=”delete” id=”${topic.id}”><g:message code=”topic.delete”></g:message></g:link>
    </shiro:hasPermission>
  </mx:item>

  <mx:item>
    <shiro:hasPermission permission=”topic:lock”>
      <g:link controller=”topic” action=”lock” id=”${topic.id}”><g:message code=”topic.lock”></g:message></g:link>
    </shiro:hasPermission>
  </mx:item>
</mx:toolbar>

And this would be rendered assuming the user has permission for both buttons:

?View Code HTML
<a href="/topic/delete/10">Delete</a>|<a href="/topic/lock/10">Lock</a>

Tag Library Source:

?View Code GROOVY
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
  }
}


]]> http://weichhold.com/2010/01/13/a-simple-gsp-toolbar-taglib-for-grails/feed/ 0 http://weichhold.com/2010/01/13/a-simple-gsp-toolbar-taglib-for-grails/ Grails sanitized stracktraces http://feedproxy.google.com/~r/olivers_place/~3/ZNXdZEXPj0c/ http://weichhold.com/2009/10/10/grails-sanitized-stracktraces/#comments Sat, 10 Oct 2009 21:01:35 +0000 oliver http://weichhold.com/?p=107 The other day I was writing a medium complex HQL query for a Grails App and no matter what the line executing the query would crash like this:

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

So how the hell do we figure out what the problem given so few information? Turns out that grails sanitizes the exception stacktrace, resulting in better readability by removing a lot of clutter. Sometimes though this optimization will also hide some important details from you. Luckily we can still refer to stacktrace.log which usually resides in the project root folder in development mode. In this particular case opening the file reveiled this:

?View Code GROOVY
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)
  ...

Which almost instantly gave me the hint that something’s wrong with the aggregate part of my query:

?View Code GROOVY
org.hibernate.hql.ast.tree.AggregateNode.getDataType

And indeed the problem was that I had ported an SQL Query to HQL and forgot to rename the sum() aggregate argument from the column name to the domain class property name:

sum(some_property) instead of sum(foo.someProperty)


]]> http://weichhold.com/2009/10/10/grails-sanitized-stracktraces/feed/ 0 http://weichhold.com/2009/10/10/grails-sanitized-stracktraces/ Configuring memcached in a Grails Application http://feedproxy.google.com/~r/olivers_place/~3/CC8S80VW6fk/ http://weichhold.com/2009/09/17/configuring-memcached-in-a-grails-application/#comments Thu, 17 Sep 2009 11:13:31 +0000 oliver http://weichhold.com/?p=95 I’m a big fan of using memcached for improving the scalability of websites so when I recently fell in love with the Grails Framework I began to look for a way to configure the memcached client which blends in with the framework. Luckily Grails provides a very easy way to configure Spring Beans using a DSL Just create grails-app/conf/spring/resources.groovy and add this:

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

Voila, from now on you can get a memcached client instance anywhere in your application either by standard dependency injection or by calling applicationContext.getBean(‘memcachedClient’).

It is important to note that this example assumes that you have configured your memcached server(s) in grails-app/conf/Config.groovy like this:

?View Code GROOVY
environments
{
  development
  {
    memcached_servers = "192.168.230.2:11211"
  }
 
  production
  {
    memcached_servers = "localhost:11211"
  }
}


]]> http://weichhold.com/2009/09/17/configuring-memcached-in-a-grails-application/feed/ 1 http://weichhold.com/2009/09/17/configuring-memcached-in-a-grails-application/ OSX and back http://feedproxy.google.com/~r/olivers_place/~3/CYsrf6EuUTo/ http://weichhold.com/2009/07/29/macosx-and-back/#comments Wed, 29 Jul 2009 19:19:25 +0000 oliver http://weichhold.com/?p=88 Recently I have abandoned my plans of switching to MacOSX as my primary Operating System after using the the OS for four months straight without touching Windows. Don’t get me wrong. I enjoyed the ride – a lot! But I also had plenty of reasons for going back to Windows (7). First of all I don’t like Apple’s attitude. I think they are turning into some kind of evil empire against which even Microsoft during its darkest days pales in comparison. I also regard Apple’s sloppy handling of serious security vulnerabilities as highly unprofessional. Then there were details that many users wouldn’t even notice. For example I’m obsessed with ClearType and could never become really comfortable with Apple’s Font Anti Aliasing which is still a lot better than Ubuntu’s though.

Anyway I decided to ditch the OS but I’m keeping the hardware – my keyboard to be precise. After typing on this fantastic keyboard for a couple of months there is no way going back to that cheap plastic crap that you usually deal with on the PC. What’s really odd is that there are peripherals vendors who are charging more for their plastic toys that do not even feature a built-in USB Hub than Apple for their anodized aluminum enclosure that offers a rock solid typing experience and even includes a USB Hub. In conjunction with an utility called SharpKeys which I use for swapping Cmd with Alt, this fine piece of craftsmanship can used pretty comfortable under windows.


]]> http://weichhold.com/2009/07/29/macosx-and-back/feed/ 1 http://weichhold.com/2009/07/29/macosx-and-back/ Updating multiple page elements with Grails and Ajax http://feedproxy.google.com/~r/olivers_place/~3/VZmYXWKnIZU/ http://weichhold.com/2009/07/20/updating-multiple-page-fragments-with-grails-and-ajax/#comments Mon, 20 Jul 2009 09:30:01 +0000 oliver http://weichhold.com/?p=39 Every Web Application Project I’ve been involved in the recent past had one thing in common: the client demanded more and more rich-client features at an ever increasing pace – without committing itself to real rich-client frameworks such as Flex or Silverlight. This leaves us with Javascript / AJAX for implementing highly dynamic User Interfaces for Web Applications. A very common problem when working with Ajax is the requirement to update multiple parts of a page in response to a single request. This post aims to familiarize the reader with my own approach to this problem.

At its core my solution consists of just two functions – one running server side and the other executing on the client. The first function is intended to run on the server and is written in Groovy. It was originally written in Python for use with the Django framework and I’ve ported it to Groovy when I switched to Grails as my primary RAD Web framework. This function takes a map as argument and returns a JSON encoded map where the key is a valid jQuery Selector designating the targets for the update and the value is a map containing information how the matched elements should be modified and how the content for the update shall be produced. Don’t worry if you find this confusing at first. There’s a sample further down.

?View Code GROOVY
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
}

The second function is written in Javascript and responsible for applying the JSON wrapped HTML fragments to their designated HTML DOM Elements:

?View Code JAVASCRIPT
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)
    }
  }
}

So how do you use it? Below you find all necessary code artifacts for implementing the described technique in arbitrary Grails application. Please note that this sample uses jQuery for carrying out the actual AJAX request but it would be trivial to port this over to any other decent Javascript Framework like MooTools, Prototype or YUI.


Let’s begin with the GSP page in /views/test/index.gsp:

?View Code ASP
<%@ 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>

The controller in /controllers/TestController.groovy:

?View Code GROOVY
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")' ]
    ])
  }
}

The call to renderElementUpdateResponse needs some explanation. Let’s step through the arguments line by line.

?View Code GROOVY
 '#div1': [ 'mode': 'replace', 'content' : [ 'fragment1': model ] ]

“[ 'fragment1': model ] ]” is the only relevant part on the server side. It means “render the GSP template /views/test/_fragment1.gsp, pass it the variable model as the model and store the resulting string as the content for the update. On the client side it tells the applyElementUpdates() function to replace (mode: replace) the output for this line in all elements with id=”div1″.

?View Code GROOVY
 '#div2': [ 'mode': 'append', 'content' : [ 'fragment2': model ] ]

Works basically the same as the previous line only that id=”div2″ is targetted and rendering /views/test/_fragment2.gsp will produce the content which is going to be appended to the target element rather than replacing it.

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

In addition to updating DOM elements we can also send code to the client which is run after all elements have been updated. Such fragments are called initializers and are identified on the client by their mode attribute which must be ‘execute’. This sample also demonstrates that fragment content can be specifed directly (alert(“The page has been updated”)) instead of being produced by rendering a template. Please note that the selector (‘__init__’) is unused in this case. The sole reason for chosing that id was to emphasize the purpose of this fragment.

The final missing bits are the aforementioned Grails templates which are going to producing the content for the updated elements.

The fragment for updating the first div in /views/test/_fragment1.gsp:

?View Code ASP
<span>Value of A is ${a}</span>

The fragment for updating the second div in /views/test/_fragment2.gsp:

?View Code ASP
<span>Value of B is ${b}</span><br/>

Finally, opening the example page on your browser and clicking the button results in the following actions:

  • The div1 element gets updated with the HTML output of rendering /views/test/_fragment1.gsp against the simple model. The contents of div1 are replaced
  • The div2 element gets updated with the HTML output of rendering /views/test/_fragment2.gsp against the simple model. The HTML is appended to the div rather then replacing the contents.
  • An alert box is displayed

That’s it folks. I hope you found this post useful.


]]> http://weichhold.com/2009/07/20/updating-multiple-page-fragments-with-grails-and-ajax/feed/ 4 http://weichhold.com/2009/07/20/updating-multiple-page-fragments-with-grails-and-ajax/ Using GIT with Grails UI-Performance Plugin http://feedproxy.google.com/~r/olivers_place/~3/EZfJxmkiEDs/ http://weichhold.com/2009/06/18/using-git-with-grails-ui-performance-plugin/#comments Thu, 18 Jun 2009 18:16:53 +0000 oliver http://weichhold.com/?p=36 I’ve been doing a serious amount of Grails Development lately and if there’s one Grails Plugin I consider mandatory for any serious production deployment then it is the UI-Performance plugin by Burt Beckwith. One of the features of the plugin that reduces server load is versioning and far-future “Expires” and “Cache-Control” headers for static resources.

Each time you generate a new WAR for deployment, a new version is applied to all image, .js, and .css files so files can be cached forever. The next time you deploy a new version of your application, all of the resource file names will have changed, so only then will files be requested. The default process for determining the version is to look at the version of the root project folder in the Subversion metadata files. Since I’ve switched to GIT for all my projects a while ago the plugin would fallback to “System.currentTimeMillis().toString()” to compute the version.

My solution is to include the following line in my projects Config.groovy:

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

This allows the HEAD commit SHA1 hash of the current branch to be used as the uiperformance version for deployment.


]]> http://weichhold.com/2009/06/18/using-git-with-grails-ui-performance-plugin/feed/ 1 http://weichhold.com/2009/06/18/using-git-with-grails-ui-performance-plugin/ VirtualPC images with Windows XP and IE http://feedproxy.google.com/~r/olivers_place/~3/CCCxakzj1jQ/ http://weichhold.com/2009/02/18/virtual-xp-images-with-windows-xp-and-ie/#comments Wed, 18 Feb 2009 01:05:47 +0000 oliver http://weichhold.com/?p=29 This is one of the very rare occasions where Microsoft actually did something cool. A couple days ago I needed to test one of my web apps with Internet Explorer 8 and just for giggles with IE6 – although we’ve dropped support for that dinosaur a while ago. Remembering my previous experience with IE8 and my inability to go back to 7 all too well – yes don’t laugh at me, I should have known better I know – I was preparing to fire up VMWare and create two XP Images, one for each browser version. But imagine my surprise when I discovered that Microsoft actually offers pre-configured ready to launch Windows XP VirtualPC Images for every possible IE version for free.

Be advised that these images expire in a couple of months but Microsoft seems to make new images  available shortly before the old ones expire.

Here’s the link: http://www.microsoft.com/downloads/details.aspx?FamilyID=7c2b5317-a40f-4e86-8835-d37170c5923e&displaylang=en


]]> http://weichhold.com/2009/02/18/virtual-xp-images-with-windows-xp-and-ie/feed/ 2 http://weichhold.com/2009/02/18/virtual-xp-images-with-windows-xp-and-ie/