Adding gradle task to a subproject in method

Question

I have a project with a bunch of subprojects. Some of the subprojects are utility projects, and some of the projects are actual applications.

The "application" subprojects should all produce a jar file with a given main class etc. To solve this I've put the following in the parent build.gradle:

def configureApplication(project, mainClass) {
    project.jar { ... }
}

and from each subproject's build.gradle, I call configureApplication(project, "my.main.Class")

Now I want to add a deploy task to all application subproject's so that I can deploy all applications using ./gradlew deploy. I've tried to mimic the above approach by putting this in the parent build.gradle:

def configureDeploy(project) {
    project {
        task deploy {
            println "Deploying!"
        }
    }
}

But I'm running in to:

Could not find method call() for arguments [build_51pn93...closure3@334ebcaa] on project ':subproj'.

I've tried about a hundred other variations for the past hour without success.

Question: How do add tasks to some of the subprojects without repeating myself in each subproject's build.gradle? (Also, is using methods in the parent build.gradle a reasonable way of achieving this, or is there a more gradle idiomatic way of doing it?)

Answer 1

I read the previous answers and their comments, especially the following statement:

I would very much like to add the deploy task to each relevant subproject through the subprojects build.gradle (while keeping code duplication to a minimum).

This sounds to me like the perfect use case for plugins. Gradle allows you to define plugins in the buildSrc subproject of your root project. Just place your plugin source code in <rootProjectDir>/buildSrc/src/main/groovy. You can find additional details in the docs.

An example plugin for your use case could look like this:

class MyDeployPlugin implements Plugin<Project> {
    void apply(Project project) {
        // you can access the project instance this plugin is applied to
        project.task('deploy') {
            // configure your task
        }
    }
}

Now you can apply the plugin in your subproject build.gradle files:

apply plugin: MyDeployPlugin

deploy {
     // configure your task project-specific
}

One last advice: People who work a lot with both Maven and Gradle, often state, that Gradle's flexibility through scripting is both the biggest advantage and the biggest disadvantage. In Maven, if you want to add or alter functionality, you often have to write a plugin. In Gradle, you can simply script the functionality, but if this happens to often, it will produce clusterfuck and unreusable code. So, whenever you need to add the same functionality to multiple (sub-)projects, use plugins. You can even publish plugins to Maven or your own repository.

Answer 2

It is indeed common to add tasks for subprojects in the parent build.gradle file.

Edit: per comments, the goal is to apply this to all subproject, and not selective ones.

Consider the following settings.gradle:

include 'appA', 'appB', 'utilityC'

Here is the root build.gradle. It defines a custom DeployTask (doc here) for each application (using subprojects), but does not configure it:

class DeployTask extends DefaultTask {
    String appName
    String destDir

    @TaskAction
    def deploy() {
        if (appName != null && destDir != null) {
            println "deploying ${appName} to ${destDir}"
        }
    }
}

subprojects { 
    task deploy(type: DeployTask) {}
}

Here is build.gradle for appA:

deploy() {
    appName = "Application A"
    destDir = "~/server/appA"
}

Here is build.gradle for appB:

deploy() {
    appName = "Application B"
    destDir = "~/web/appB"
}

In this simple example, utilityC does not have a build.gradle

Example output:

$ gradle :appA:deploy 
deploying Application A to ~/server/appA

and

$ gradle :appB:deploy 
deploying Application B to ~/web/appB

and

$ gradle :utilityC:deploy 
[no output]

Answer 3

I would strongly suggest creating a custom groovy class in your buildSrc with configurable parameters. And then configure them in gradle.

class DeployTask extends DefaultTask {

    def deploymentName, targets, source, deploymentPlan

    @TaskAction
    def deploy() {
       // your stuff using above variables                
    }

}

You can use a subprojects{} in main build.gradle to specify everything there instead of repeating yourself.

subprojects { project ->

    if (project.name.contains('application1')) {

        task deploy (type: package.DeployTask) {
            source          = ""
            deploymentName  = ""
            targettype      = ""
        }

    }

    if (project.name.contains('application2')) {

        task deploy (type: package.DeployTask) {
            source          = ""
            deploymentName  = ""
            targettype      = ""
        }

    }

}

or simply add it to the projects itself.

This is going to iterate through all subprojects specified in settings.gradle and create a task deploy for each subproject that met the above condition.

---

I See @Michael Easter did actually explain it already in a separate answer, and I Agree I have my apps deployed to Weblogic in exactly same way.