Comments on: Using Gant to execute a groovy script within the Grails context (updated)

By: tednaleid

tednaleid — Wed, 10 Dec 2008 02:56:53 +0000

I’ve never seen that kind of behavior before. You could try putting “flush:true” in your save method to see if that fixes things.

Also, if you’re not letting the script exit normally (but doing some sort of System.exit(0)) that could potentially interrupt things too.

By: Peter-Frank Spierenburg

Peter-Frank Spierenburg — Tue, 09 Dec 2008 23:46:58 +0000

Upon further examination, there appears to be some kind of time-delay between statements in the frails shell and SQL winding up in prodDB.log. If I kill the shell too early, no SQL gets logged, and the user is effectively not created. I suspect that what is going on is that the GANT script ends before the database layer has an opportunity to persist the data. I hope I don’t have to add a time delay to my GANT script to account for this. Is there some kind of synchronization method that I can call to ensure that save()d data are actually persisted?

Peter.

By: tednaleid

tednaleid — Tue, 09 Dec 2008 06:47:42 +0000

Peter, that sounds more like a problem with your member save code than the script. Are you sure it saved?

If you open up a “grails console” and paste your script in there and run it, does it get saved in the DB?

Make sure you try to “validate()” before saving to ensure that you have all of the required fields on your domain object. See the grails docs on validation for more details.

Also, make sure that you’re running the script against the environment that you think you’re running it against. You can specify your environment as the first grails parameter:

grails prod run-script userScripts/env.groovy

You can see what environment is currently running by putting this in your script:

println grails.util.GrailsUtil.environment

If I save that to userScripts/env.groovy and run the above command it prints out “production”.

By: Peter-Frank Spierenburg

Peter-Frank Spierenburg — Mon, 08 Dec 2008 20:29:29 +0000

I’m trying to create a script to add new members to my webapp. I’m trying to invoke the MemberController’s save() method to save the new member. The script claims to have created the new member, and I can find the new member using Member.findAll(), but the member’s record doesn’t show up in the database (when I choose production). And when I run the script a second time, Member.findAll() only finds the newly created member, not any of the members I’ve already created.

Peter.

By: Steve

Steve — Wed, 11 Jun 2008 23:31:48 +0000

Sorry for the delay. I ended up just running my script in the grails console. I’m not familiar enough with grails to try what was suggested by Armin.

By: tednaleid

tednaleid — Mon, 02 Jun 2008 05:05:29 +0000

@Steve Did it give you some sort of error, or were the items just not found? If they weren’t found, I’d be sure that you’re calling the script with the right environment (noted in the comments above). If you’re getting an error, does the stuff mentioned above by Armin Heinzer fix things for you?

By: Steve

Steve — Sun, 01 Jun 2008 20:08:20 +0000

I tried your code to load my script, but my script wasn’t able to read existing entries in the database (which works when loaded into grails console).

By: tednaleid

tednaleid — Sat, 31 May 2008 18:10:13 +0000

@Oliver, yes, the current script doesn’t pass any arguments to the script and simply treats all parameters as separate script files.

It wouldn’t be that hard to change it to have it instead only parse a single file and pass the parameters along to the calling script.

The call to parseArguments would simply grab the first parameter as the file name and create a variable that contains the remaining arguments.

Then, executeScript would add the remaning parameters as a new item in the Binding object.

Here’s an updated script with these changes (I called it RunScriptWithParms.groovy):

import org.codehaus.groovy.grails.commons.GrailsClassUtils as GCU
import org.springframework.orm.hibernate3.SessionFactoryUtils
import org.springframework.orm.hibernate3.SessionHolder
import org.springframework.transaction.support.TransactionSynchronizationManager
 
grailsHome = Ant.project.properties."environment.GRAILS_HOME"
 
includeTargets << new File ( "${grailsHome}/scripts/Package.groovy" )
includeTargets << new File ( "${grailsHome}/scripts/Bootstrap.groovy" )
 
target('default': "Execute the specified script after starting up the application environment") {
    depends(checkVersion, configureProxy, packageApp, classpath)
    runScript()
}
 
target(runScript: "Main implementation that executes the specified script after starting up the application environment") {
    parseArguments()
    if (argsMap["params"].size() == 0) {
        event("StatusError", ["Required script name parameter is missing"])
        System.exit 1
    }
    compile()
    classLoader = new URLClassLoader([classesDir.toURL()] as URL[], rootLoader)
    Thread.currentThread().setContextClassLoader(classLoader)
    loadApp()
    configureApp()
	configureHibernateSession()
	scriptFile = argsMap["params"].getAt(0)
	// remove our script name from the params so when we call the script it's not in there
	argsMap["params"].remove(scriptFile)
    executeScript(scriptFile, classLoader, argsMap)
}
 
def configureHibernateSession() {
	// without this you'll get a lazy initialization exception when using a many-to-many relationship
	def sessionFactory = appCtx.getBean("sessionFactory")
	def session = SessionFactoryUtils.getSession(sessionFactory, true)
	TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session))
}
 
def executeScript(scriptFile, classLoader, argsMap) {
    File script = new File(scriptFile)
    if (script.exists()) {
        def shell = new GroovyShell(classLoader, new Binding(ctx: appCtx, grailsApplication: grailsApp, argsMap: argsMap, args: args))
        shell.evaluate(script.text)
    } else {
        event("StatusError", ["Designated script doesn't exist: $scriptFile"])
    }
}
 
// this argument parsing target was submitted as a patch to grails and is availble in Init.groovy as of 1.0.3
// see http://jira.codehaus.org/browse/GRAILS-2663
 
argsMap = [params: []]
 
target(parseArguments: "Parse the arguments passed on the command line") {
    args?.tokenize().each {  token ->
        def nameValueSwitch = token =~ "--?(.*)=(.*)"
        if (nameValueSwitch.matches()) { // this token is a name/value pair (ex: --foo=bar or -z=qux)
            argsMap[nameValueSwitch[0][1]] = nameValueSwitch[0][2]
        } else {
            def nameOnlySwitch = token =~ "--?(.*)"
            if (nameOnlySwitch.matches()) {  // this token is just a switch (ex: -force or --help)
                argsMap[nameOnlySwitch[0][1]] = true
            } else { // single item tokens, append in order to an array of params
                argsMap["params"] << token
            }
        }
    }
    event("StatusUpdate", ["Done parsing arguments: $argsMap"])
}

If you have this groovy script (userScripts/showParams.groovy):

println "in showParams script, argsMap is: $argsMap"
println "in showParams script, raw args are: $args"

And call it with this command line:

grails run-script-with-parms userScripts/showParams.groovy --foo=zazz -b=quux

You’ll get this as a result with the args passed in:

in showParams script, argsMap is: ["params":[], "foo":"zazz", "b":"quux"]
in showParams script, raw args are: userScripts/showParams.groovy
--foo=bar
--foo=zazz
-b=quux

By: Oliver

Oliver — Sat, 31 May 2008 09:59:00 +0000

Thanks. Another question: It is currently not supported to pass arguments to the script because you basically treat all arguments as seperate script files right?

By: tednaleid

tednaleid — Fri, 30 May 2008 14:23:56 +0000

@Oliver

By default, scripts run in the development environment. You can run any script in another environment by using the -Dgrails.env parameter.

Here’s an example running in the “test” environment (where environments are defined in the grails-app/conf/Config.groovy file)

grails -Dgrails.env=test run-script userScripts/createBook.groovy

You can take a look at the environments section of the Grails documentation for more information.