Grails Tutorials

Grails product info Auto Increment build number – Continuous Integration

Set up an auto increment build number using Jenkins using a maven build

Grails Maven enabling non interactive mode

Enabling non interactive mode Grails Maven enabling in Continuous Integration Server for answering plugin updates

Exposing Grails services as remoting services consumed mobile, web and desktop clients

The link leads to a blog post that contains links to screencast, documentation and a tutorial on how WebORB can be used to simplify creating client apps that connect to Grails services. Remoting is one of the communication models WebORB supports. WebORB also supports messaging and media streaming for Grails apps.

How to Annotate Grails Controller Classes And Actions

A blog post explaining how to annotate your Grails controller classes and actions.

Counting Many To Many Relationships With Grails

A blog post on counting many to many relationships with grails.

Externalize and reload grails configuration dynamically

Configuration file plays great role in grails. You can store application specific configuration at one place. One of the grails goodies is that you can externalize configuration file i.e. store them at a location so that it is not packed with the war file.

Integrating Qooxdoo with Grails

This tutorial explains how to integrate qooxdoo with grails.

Time durations

Some code that shows durations and works nicely as a timer

Grails replaceAll With Captured Groups/Backreferences

In a Grails app, I found myself needing to do a regex search, save captured groups/backreferences (I’m not sure of the distinction between those terms), and replace them with new content, which includes those backreferences. But I was having trouble finding a way to do it.

Grails: Splitting up resources.groovy

Grails provides a neat way to specify Spring bean definitions with its custom Beans DSL [0]. The bean definition is found in grails-app/conf/spring/resources.groovy

Detecting the Grails Environment in a GSP

Last night I needed to make sure that my analytics tracking script was not running anywhere but in my production environment. After reading another blog post I came up with this simple GSP if block.

Using Hudson to run tests in parallel

We have been using Hudson to do CI on our grails application for a few months now. We use it to run unit, integration, jsunit, and functional (via selenium) tests, as well as code coverage metrics using Cobertura. Since this was the first project that we used Hudson for, the person who originally set it up just put all of these steps into a single job. It worked fairly well, but a single build was taking between 20-30 minutes, depending on how extensive the changes were. This can be a real pain, especially during very active development cycles when you most need rapid feedback. I decided to look into how I could run the tests in parallel, and hopefully get our build times to under 5 minutes.

Working with Transactions in Grails

At a certain point when developing an application you will run into a situation that requires you to use transactions. With transactions (in it’s simplest form) you basically control when/whether to commit/rollback a bunch of related sql inserts, updates and/or deletes depending on your business requirements.

Grails, is it only for Prototypes?

Perhaps it’s dismissed as immature by many programmers because it’s so easy to use, it seems too good to be true. Or perhaps because of a crowd so accustomed to minutely configuring everything, they distrust Convention over Configuration. Whichever the reason, Grails is, after several years, still viewed as an amateurish Framework that many don’t take seriously.

Dynamic GORM Domain Classes

A recent discussion on the Grails Dev mailing list about creating a dynamic form builder involved needing to compile new domain classes at runtime. The consensus seemed to be that it's not possible and/or not advisable, but I've thought a lot about this topic and had done similar work when creating the Dynamic Controller plugin, so I started playing with it.

Hosting Grails web applications using Tomcat and Nginx (our configuration)

To host Grails web application Apache Tomcat is quite a natural choice. However a big part of what is served are just static files (images, CSS, javascript code) or rarely changed pages. Using Tomcat to serve all that stuff would be a waste of resources, especially when running on small VPS like we do. Nginx is a small efficient web server that helps with this task. It can be setup to both serve static files and act as reverse proxy to Tomcat running the Grails application. Even more, it can cache some of the web pages so that it sends less requests to Tomcat. In this post I’ll highlight important parts of Nginx and Tomcat configuration files needed to achieve setup like this.

Grails functional testing with hudson, selenium-rc, and easyb

recently integrated functional selenium into our build process so that we could automate the regression scripts. Most of this was straight forward as grails has plugins for selenium and easyb, but there were a couple extra steps I needed to get them working together so I thought I would share them here for those of you that are interested.

Grails and JCifs

As part of a project to provide schools and businesses with an open source solution to access their "My Documents" folder anytime/anywhere over the web, I recently had the pleasure of integrating JCIFS into my Grails application

Grails controllers and command objects

Well, I've been asked to implement a functionality, a very simple one. Take 2 parameters from the URL, verify if all of them are given, check if one is a valid identifier of an existing entry in the database and if so set a given property of that domain object to the value of the other parameter. Let's see how this might be done:

GonG - Getting Groovy - 1 - Installing Groovy and Grails

This is a quick reference and packaged version of installing, developing and deploying Groovy on Grails (GonG) application. Trust me, it is much faster, easier and fun that running JSP, JSF, Spring and Hibernate(We will see how to integrate some of these with GonG).