I revisit the Ant Hook scripts using Groovy and change it to use INIX file for hook storage and use XML transform via XMLTask to insert the hook feature into a legacy build script.
In a prior post, Ant hooks using Groovy, continued, I used the Ant BuildListener interface to add a hooks feature that invokes a Groovy script mapped to build events. Then I implemented an “around advise” capability.
Many issues with this approach, but two stand out.
- Existing Ant scripts must be modified to add this in.
- Hook scripts are now a bunch of files that must be managed.
- Hook scripts are stored in INIX files
- A meta build step is used to insert the hook feature into a build script.
INIX storage
Below, the Groovy hook scripts from the previous blog post are stored in the sections of a INIX file (a form of INI file). The section begin tag is composed of a unique path, optional fragment identifier, and a query string. Just like a URL. The query string indicates when this hook is applied and if the target in the script should be skipped (applicable for ‘before’ hooks). The last section in the file will be discussed later.
[>hook/root/compile?when=after,skip=false] println " hook: root,{target=${event.target.name},when=post,event=$event}" [<] [>hook/demo1/deploy?when=before,skip=true] println " hook: {project=${event.project.name},target=${event.target.name},when=pre,event=$event}" [<] [>hook/demo1/compile?when=before,skip=false] println " hook: {project=${event.project.name},target=${event.target.name},when=pre,event=$event}" [<] [>fragment] <path id="libs"> <fileset dir="lib"> <include name="groovy-all-2.2.1.jar" /> </fileset> <pathelement location="src/main/groovy"/> </path> <!-- Groovy library --> <taskdef name="groovy" classname="org.codehaus.groovy.ant.Groovy" classpathref="libs"/> <!-- sets a BuildListener to the project --> <scriptdef name="set-listener" language="Groovy" classpathref="libs" src="src/main/groovy/com/octodecillion/util/ant/Hook.groovy"> <attribute name="path"/> </scriptdef> <!-- install the listener --> <set-listener path="hooks.inix"/> [<fragment]
[/expand]
Ant build file transform
In the above inix file, the last section contains the XML fragment of the build script hook support. We read in this section and use Groovy’s Templating support to replace any values. Thus, by running a metabuild or bootstrap process we can take that fragment and insert it into a target Ant script.
Since an Ant script is XML, an XML transform is used by the XMLTask Ant task. This task allows us to indicate with an XPath expression where to insert the fragment. In a Groovy blog post, we of course, will use Groovy to do this via the Groovy AntBuilder. Below, the InsertHooks class implements this.
package com.octodecillion.util.ant import static com.octodecillion.util.inix.Inix.EventType.END import com.octodecillion.util.inix.Inix import org.apache.tools.ant.* import static groovy.io.FileType.FILES /** * Insert the XML into Ant script to enable hooks. * * @author josef betancourt */ class InsertHooks{ def ant def DEBUG = false static final String srcFilePath='build.xml' static final String destFilePath="build-hooked.xml" static final String INIXFILE = 'hooks.inix' static final String XMLTASK = 'com.oopsconsultancy.xmltask.ant.XmlTask' static main(args){ new InsertHooks().execute() } /** An Ant task entry point */ public void execute() throws BuildException{ def ant = new AntBuilder() try { def fragment = loadFragment(INIXFILE) if(!fragment){ throw new BuildException("'fragment' from $INIXFILE is invalid") } def engine = new groovy.text.SimpleTemplateEngine() def template = engine.createTemplate(fragment) def xml = template.make([hookFilePath:INIXFILE]) ant.path(id: "path") { fileset(dir: 'lib') { include(name: "**/xml*.jar") } } ant.taskdef(name:'xmltask',classname: XMLTASK, classpathref: 'path') def xpath = '(//target)[1]' ant.xmltask(source:srcFilePath,dest:destFilePath, expandEntityReferences:false,report:false){ insert(position:"before",path:xpath,xml:xml) } new File(destFilePath).eachLine{ println it } } catch (Exception e) { e.printStackTrace() throw new BuildException(e.getMessage(), e) } } def loadFragment(String path){ def text = '' def inix = new Inix(path) def theEvent = inix.next() while(theEvent && theEvent != Inix.EventType.END ){ Inix.Event event = inix.getEvent() if(event.isSection("fragment")){ text = event.text break } theEvent = inix.next() } return text } } // end Script
[/expand]
Hooking Up
Now the target Ant script has the ability to invoke the script below via a ScriptDef. The script wires in the Ant BuildListener interface implementation, and then loads the hooks from the inix file. When the Ant script is run, the BuildListener’s invokeTargetHook method is invoked. This in turn executes the correct hook scripts.
package com.octodecillion.util.ant import groovy.transform.TypeChecked; import groovy.transform.TypeCheckingMode; import java.util.List; import java.util.Map; import java.util.regex.Pattern import com.octodecillion.util.inix.Inix import org.apache.tools.ant.BuildEvent import org.apache.tools.ant.BuildException import org.apache.tools.ant.Project import org.apache.tools.ant.SubBuildListener; import static groovy.io.FileType.FILES // wire in the listener def path = binding.attributes.get('path') if(!path){ throw new BuildException("'path' to hook inix not set") } def listener = new HookListener(project,path) listener.project = project project.addBuildListener(listener) // end wiring /** * Ant build listener that invokes groovy hook scripts. * * @author josef betancourt * */ @TypeChecked class HookListener implements SubBuildListener { Project project boolean DEBUG = false /** */ def HookListener(Project project, String path){ this.project = project loadInix(path) } /** load scripts in inix file */ def loadInix(String path){ debugln("load inix") def inix = new Inix() inix.reader = new BufferedReader( new FileReader(new File(path))) def theEvent = inix.next() def found = false while(theEvent && theEvent != Inix.EventType.END ){ def event = inix.getEvent() if(isHook(event)){ found = true def key = [event.path[2],((String)(event.params['when'])). toUpperCase()].join('/') String txt = event.text String skString = event.params['skip'] boolean sk = (skString.compareTo('true')==0 ? true : false) debugln "key=$key, ${event.params['skip']}, skip=$sk" def node = new HookNode(txt, sk) def prj = event.path[1] if(!hooks[prj]){ hooks[prj] = [:] } hooks[prj].put(key,node); } theEvent = inix.next() } dumpHooks() } /** invoked by Ant build */ @Override public void targetStarted(BuildEvent event) { die("targetStarted invoked with null event", !event) invokeTargetHook(event, When.BEFORE) } /** invoked by Ant build */ @Override public void targetFinished(BuildEvent event) { die("targetFinished invoked with null event", !event) invokeTargetHook(event, When.AFTER) } /** Invoke the target's hook script */ def invokeTargetHook(BuildEvent event, When when){ def b = new Binding() b.setProperty("event",event) b.setProperty("hook",this) def shell = new GroovyShell(b) def hookName = "${event.target.name}/$when" def pHook = hooks[event.project.name][hookName] def rHook = hooks['root'][hookName] debugln("invokeTargetHook: $hookName\npHook: $pHook\nrHook: $rHook") boolean skipSet = false if(pHook){ skipSet = pHook.skip debugln("skipSet=$skipSet") shell.evaluate(pHook.text) if(!override && rHook){ skipSet = skipSet ? skipSet : rHook.skip shell.evaluate(rHook.text) } }else if(rHook){ skipSet = rHook.skip shell.evaluate(rHook.text) } if( skipSet && (pHook || rHook) && (when == When.BEFORE) ){ createSkipforTarget(event) } } /** */ private createSkipforTarget(BuildEvent event) { debugln "setting skip: ${event.target.name}_skipTarget" event.project.setProperty("${event.target.name}_skipTarget", "true") event.target.setUnless("${event.target.name}_skipTarget") } /** throw exception if flg is true */ private die(Object msgObject, boolean flg){ if(flg){ throw new IllegalArgumentException(String.valueOf(msgObject)) } } @TypeChecked(TypeCheckingMode.SKIP) private isHook(ev){ ev.path && ev.path[0] == 'hook' } private dumpHooks() { if(!DEBUG){ return } hooks.each{ it.each{ node -> debugln(node) } } } private debugln(Object msg){ if(DEBUG){ println(msg) } } String TARGETHOOK = "target" def override = true; enum When{ BEFORE('before'),AFTER('after') String name When(s) {this.name = s} } private class HookNode { String text boolean skip public HookNode(String text, boolean skip){ this.text = text this.skip = skip } def String toString() {return "s:$skip"}; } Map<String, Map<String,HookNode>> hooks = [:] //@formatter:off @Override public void subBuildFinished(BuildEvent event) {} @Override public void subBuildStarted(BuildEvent event) {} @Override public void buildFinished(BuildEvent event) {} @Override public void buildStarted(BuildEvent event) {} @Override public void messageLogged(BuildEvent event) {} @Override public void taskFinished(BuildEvent event) {} @Override public void taskStarted(BuildEvent event) {} //@formatter:on } // end class HookListener // end Script
[/expand]
Demo
Below is a non-hooked Ant script.
<project name="demo1" default="build" basedir="."> <target name="compile"> <echo>******* 'compile': Hello compile world!</echo> </target> <target name="deploy"> <echo>******* 'deploy': Deploying ... ${skipSet}</echo> </target> <target name="build" depends="compile,deploy"> <echo>******* 'build': Building ... </echo> </target> </project>
[/expand]
When we run the InsertHooks scripts, a new Ant script is created, build-hooked.xml. The console output (for demonstration) is:
Output
<?xml version="1.0" encoding="UTF-8" standalone="no"?> <project basedir="." default="build" name="demo1"> <path id="libs"> <fileset dir="lib"> <include name="groovy-all-2.2.1.jar"/> </fileset> <pathelement location="src/main/groovy"/> </path> <!-- Groovy library --> <taskdef classname="org.codehaus.groovy.ant.Groovy" classpathref="libs" name="groovy"/> <!-- sets a BuildListener to the project --> <scriptdef classpathref="libs" language="Groovy" name="set-listener" src="src/main/groovy/com/octodecillion/util/ant/Hook.groovy"> <attribute name="path"/> </scriptdef> <!-- install the listener --> <set-listener path="hooks.inix"/> <target name="compile"> <echo>******* 'compile': Hello compile world!</echo> </target> <target name="deploy"> <echo>******* 'deploy': Deploying ... ${skipSet}</echo> </target> <target depends="compile,deploy" name="build"> <echo>******* 'build': Building ... </echo> </target> </project>
[/expand]
Then we subsequently run the build-hooked.xml script, the console output is shown below. Note that the “deploy” target is skipped, only the output of the hook will show.
Buildfile: C:\Users\jbetancourt\workspace-4.3\AntAroundAdvice2\build-hooked.xml compile: hook: {project=demo1,target=compile,when=pre,event=org.apache.tools.ant.BuildEvent} [echo] ******* 'compile': Hello compile world! hook: root,{target=compile,when=post,event=org.apache.tools.ant.BuildEvent} deploy: hook: {project=demo1,target=deploy,when=pre,event=org.apache.tools.ant.BuildEvent} build: [echo] ******* 'build': Building ... BUILD SUCCESSFUL Total time: 3 seconds
Summary
Shown was an improvement of the Groovy Ant Hooks idea. If nothing else, shown was some Groovy code that used AntBuilder, XMLTask, and Inix file reading.
The actual use case for the need of a Ant hook is probably very narrow, such as a build server that reuses legacy Ant build scripts, or the targeting of legacy build to new requirements.
Further reading
- ABuilds use of Ant hooks So far, the only Ant hook mention I’ve located
- Groovy Goodness: Using Groovy for Git Hooks
2 thoughts on “Ant hooks using Groovy, INIX, and XMLTask”