CODEWITHSUNDEEP
gradletask
Mike HT
Mike HT

Reputation: 313

Gradle custom task action order

I'm looking at a simple example of a custom task in a Gradle build file from Mastering Gradle by Mainak Mitra (page 70). The build script is:

println "Working on custom task in build script"

class SampleTask extends DefaultTask {
    String systemName = "DefaultMachineName"
    String systemGroup = "DefaultSystemGroup"
    @TaskAction
    def action1() {
      println "System Name is "+systemName+" and group is "+systemGroup 
    }
    @TaskAction
    def action2() {
      println 'Adding multiple actions for refactoring'
    }

}

task hello(type: SampleTask)
hello {
    systemName='MyDevelopmentMachine'
    systemGroup='Development'
}

hello.doFirst {println "Executing first statement "} 
hello.doLast {println "Executing last statement "}

If I run the build script with gradle -q :hello, the output is:

Executing first statement 
System Name is MyDevelopmentMachine and group is Development
Adding multiple actions for refactoring
Executing last statement

As expected with the doFirst method excecuting first, the two custom actions executing in the order in which they were defined, then the doLast action executing. If I comment out the lines adding the doFirst and doLast actions, the output is:

Adding multiple actions for refactoring
System Name is MyDevelopmentMachine and group is Development

The custom actions are now executing in the reverse order in which they are defined. I'm not sure why.

Upvotes: 9

Views: 2806

Answers (3)

2BAB
2BAB

Reputation: 1433

It doesn't guarantee the order.

For your information, just added one more link which was an issue I raised few years ago, it should be giving warnings or replaced with some other better solutions by Gradle.

https://github.com/gradle/gradle/issues/8118

Upvotes: 1

RenatoIvancic
RenatoIvancic

Reputation: 2092

Patrice M. is correct, the way those methods will be executed is undeterministic.

In detail

@TaskAction annotated methods are being processed by AnnotationProcessingTaskFactory.

But first Task action methods are fetched with DefaultTaskClassInfoStore and results stored in TaskClassInfo.

You can see that Class.getDeclaredMethods() is being used to fetch all methods to check if they contain @TaskAction annotation

And here the definition of public Method[] getDeclaredMethods() throws SecurityException

Description contains following note:

The elements in the returned array are not sorted and are not in any particular order.

Link to Gradle discussion forum with the topic about @TaskAction

Upvotes: 3

Patrice M.
Patrice M.

Reputation: 4319

I think it's simply a case that the ordering is not deterministic, and you get different results depending on how you further configure the task.

Why do you want 2 separate @TaskAction methods as opposed to a single one that calls methods in a deterministic sequence, though ? I can't think of a particular advantage of doing it that way (I realize it's from a sample given in a book). Most other samples I find only have a single method 

@TaskAction 
void execute() {...}

which I think makes more sense and be more predictable.

Upvotes: 5

Related Questions