Glassfish v2 and v3 Prelude comes with an internal database JavaDB (based on the Apache Derby) that could be used for first tests. It would be great to use the default database by default for deployments for Glassfish via JNDI. This article shows how to use the bundled database with an Grails application.

In preparation for the next steps you have to install Grails 1.1 and Glassfish v2 or Glassfish v3 Prelude.

To create the demo app just run the following at command line:

grails create-app glassfishapp
cd glassfishapp
grails create-domain-class Bookmark
grails create-controller Bookmark


As the next step edit the domain class and the controller. E.g. open Eclipse with installed Groovy plugin.

class BookmarkController {
    def scaffold = Bookmark
}

class Bookmark {
    static constraints = {
    }
 
    String url
}

Now you are ready to test your app with


grails run-app


To prepare the Grails application for Glassfish the data source for the production environment has to be changed. Open the DataSource.groovy and change

production {
	dataSource {
		dbCreate = "update"
		url = "jdbc:hsqldb:file:prodDb;shutdown=true"
	}
}

to

production {
	dataSource {
		dbCreate = "update"
		// do not use java:/jdbc as documented
		jndiName = "jdbc/__default"
		username = "APP"
		password = "APP"
	}
}

Do not use jndiName = "java:jdbc/__default" as documented. Be aware that it may be dangerous to use dbCreate= "update" in production environments.

Now compile the web archive with

grails war

Start your database and the application server
./asadmin start-database
./asadmin start-domain

Finally open the sun web interface at http://localhost:4848/ to deploy the war file

http://localhost:8080/glassfishapp-0.1/

I experienced some memory problems by using Grails with Glassfish. To fix that problem I added -XX:MaxPermSize=256m and -Xmx1024m as JVM option. JVM options can be changed via the web interface (Common Tasks -> Application Server -> JVM Settings -> JVM Options)

Grails running in Glassfish

 
class UrlMappings {
   static mappings = {
          // identifies a rest object like /rest/airport/1
	  "/rest/$domain/$id"{
		  controller = "rest"
		  action = [GET:"show", PUT:"create", POST:"update",DELETE:"delete"]
         }
   }
}

The action attribute may be a simple string, a hash map or a closure. Grails calls the following method evaluateNameForValue(Object value, GrailsWebRequest webRequest) to retrieve the value. The method is located within the org.codehaus.groovy.grails.web.mapping.DefaultUrlMappingInfo.

private String evaluateNameForValue(Object value, GrailsWebRequest webRequest) {
        if (value == null) {
            return null;
        }
        String name;
        if (value instanceof Closure) {
            Closure callable = (Closure) value;
            Object result = ((Closure) callable.clone()).call();
            name = result != null ? result.toString() : null;
        } else if (value instanceof Map) {
            Map httpMethods = (Map) value;
            name = (String) httpMethods.get(webRequest.getCurrentRequest().getMethod());
        } else {
            name = value.toString();
        }
        return name;
    }

Due to our knowledge of the action retrieval process, we are able to implement a “_method” emulation. This could look like:

 
class UrlMappings {
   static mappings = {
          // identifies a rest object like /rest/airport/1
	  "/rest/$domain/$id"{
		  controller = "rest"
		  // action = [GET:"show", PUT:"create", POST:"update",DELETE:"delete"]
 
	         action = {
		   // closure will not be invoked with request, log ... therefore we have to do this manually
		  GrailsWebRequest webRequest = (GrailsWebRequest) RequestContextHolder.getRequestAttributes();
		  String method = webRequest.getCurrentRequest().getMethod();
		  String methodParam = webRequest.getCurrentRequest().getParameter("_method");
 
		  // check if we can use _method
		  if (methodParam != null) {
		    methodParam = methodParam.toUpperCase()
 
		    switch (methodParam) {
			case "PUT" :
			case "DELETE" :
			case "POST" :
			case "GET" :
			  method = methodParam;
			break
		  }
		} 
 
		switch (method.toUpperCase()) {
		  case "PUT" : return "create"
			break
		  case "DELETE" : return "delete"
			break
		  case "POST" : return "update"
			break
		  case "GET" : return "show"
			break
		  default:  return "show"
		        break
		}
		return method;
		}
         }
   }
}

I hope that helps all Grails REST developers to enable their services for J2ME.

Right after installation I faced some issues:

Secure your Rest Services

This sounds quite easy due to a simple switch within the SecurityConfig.groovy. Just activate the BasicProcessingFilter. Now grails uses the Http Basic Authentification.

/** use basicProcessingFilter */
basicProcessingFilter = true

At the client side the code would like:

import sun.misc.BASE64Encoder
import groovy.util.XmlSlurper
 
def userid = "john.doe"
def password = "pass"
 
def url = "http://localhost:8080/CandyStreamServer/rest/gps/"
 
def conn = new URL(url).openConnection()
 
if (userid && password) {
	println "set authorization"
 
	// add HTTP authentication
       String encodedAuth = new BASE64Encoder().encode((userid + ":" + password).getBytes()) 
 
	conn.setRequestProperty("Authorization", "Basic " + encodedAuth)
}
 
def slurper = new XmlSlurper()
 
conn.requestMethod = "GET"
conn.doOutput = true
 
println "check connection"
def response
if (conn.responseCode == conn.HTTP_OK) {
	conn.inputStream.withStream {
		response = slurper.parse(it)
	}
} else {
	response = conn.responseCod
}
println response
conn.disconnect()

Retrieve the Current User

On the server side it may necessary to retrieve the current user. Spring Security offers a SecurityContextHolder. Unfortunately the securityContext.getAuthentication().getPrincipal(); does not return the Groovy user object. Instead the Spring Security Plugin uses its own user implementation that holds the Groovy user object. This is required due to Springs dependency on a specific interface.

The plugin provides a org.codehaus.groovy.grails.plugins.springsecurity.GrailsUser interface that extends the org.springframework.security.userdetails.UserDetails interface. To retrieve your Groovy user object just call getDomainClass()

SecurityContext securityContext = SecurityContextHolder.getContext();
def springUser = securityContext.getAuthentication().getPrincipal();
return springUser.getDomainClass()

1. Create a new grails application: grails create-app openID

2. Change into directory: cd openID

3. Install Plugin: grails install-plugin openid

4. Create a new controller: grails create-controller User

5. Create logon.gsp at grails-app/views/user

6. Add the following lines of code

<openid:css />
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
<meta name="layout" content="main" />
<title>Login</title>
<openid:css />
</head>
<body>
<h1>Login</h1>
<openid:hasLoginError>
<div class="errors">
<ul>
<li><openid:renderLoginError /></li>
</ul>
</div>
</openid:hasLoginError>
<openid:form success="[action:'loggedin']">
<openid:input size="30" value="http://" /> (e.g. http://username.myopenid.com)
<br/>
<g:submitButton name="login" value="Login" />
</openid:form>
</body>
</html>

7. Edit UserController and add

class UserController {
def login = { }
def loggedin = { redirect(uri:'/') }
}

8. Call grails run-app

9. Open your web browser at http://localhost:8080/openID/User/login.gsp

10. Use your OpenID account to log on like Yahoo OpenID.

Check out http://docs.codehaus.org/display/GRAILS/OpenID+Plugin for further information about the Grails openID plugin