Points to Remember

1. Default location for gradle dependencies is ~/.gradle or /home/{user}/.gradle.
2. We can specify the location from where to gradle should find dependencies and where it should upload the created artifacts.

How to upload an Artifact to a custom location in file system

buildscript {
    repositories {
        maven {
            url uri("$buildDir/repo")
        }
    }
}

group 'com.ekiras'
version '1.0-SNAPSHOT'

apply plugin: 'groovy'
apply plugin: 'maven'

repositories {
    mavenCentral()
}

dependencies {
    // dependencies
}
uploadArchives {
    repositories {
        mavenDeployer {
            repository(url: uri("$buildDir/repo"))
        }
    }
}

In the above example,

uploadArchives {
    repositories {
        mavenDeployer {
            repository(url: uri("$buildDir/repo"))
        }
    }
}

This tells gradle that it will upload the created artifact (jar or war ) to the directory build/repo. You can specify any location on your machine where you want gradle to upload the artifact.

buildscript {
    repositories {
        maven {
            url uri("$buildDir/repo")
        }
    }
}

The above code tells gradle that it should look for the given dependencies in this repository/directory we have specified to resolve the specified dependencies. You can also specify the same in repositories { } closure.

Points to Remember

1. War task extends Jar
2. You can create war files with any configuration defined in configurations { } closure
3. You can also add files to an existing war file.
4. You can select the files that needs to be included or excluded while creating a war file

How to create a War file in Gradle

To create a war file you have to create a task of type War as shown below

// include java plugin 
apply plugin : 'java'

task createWar(type : War){
    destinationDir = file("$buildDir")
    baseName = "my-war"
    version = "1.1"
    caseSensitive = true
    classifier = "SNAPSHOT"
    from "src"
}

Run the above task with command gradle -q createWar, this will create a war file named my-war-1.1-SNAPSHOT.war in the build folder.

See Full Documentation of War Task

How to create a War file and exclude some files

Now if we want to exclude some files from a war file we can use the exclude method which takes Set<String>, and excludes them from the war file. Lets see an example below

task createWar(type : War){
    destinationDir = file("$buildDir")
    baseName = "my-war"
    version = "1.1"
    caseSensitive = true
    classifier = "SNAPSHOT"
    from("src/main"){
        excludes = [
            "resources/test.txt"
        ]
    }
}

The above task will create a war file and will exclude the file test.txt from directory src/main/resources/ .

How to create a War file and include files from some other directory

You may also get a scenario when you have to include some files from some other directory to the war file. To do that you can use the includes method and define an array of files or folders to be included.

task createWar(type : War){
    destinationDir = file("$buildDir")
    baseName = "my-war"
    version = "1.1"
    caseSensitive = true
    classifier = "SNAPSHOT"
    from("src/main"){
        excludes = [
            "resources/**"
        ]
    }
    from("src/demo"){
        includes = [
             "a.txt",
             "b.txt"
        ]
    }
}

The above task will include the files from src/main folder and src/demo folder and make a war file.

Copy files to an War file at custom location

You may need to copy some files to the war file in some custom directory. Lets say, you want to copy configuration files from directory src/conf to folder /conf in the war file. Then you can write the task as shown below

task createWar(type : War){
    destinationDir = file("$buildDir")
    baseName = "my-war"
    version = "1.1"
    caseSensitive = true
    classifier = "SNAPSHOT"
    from("src/main"){
        excludes = [
            "resources/**"
        ]
    }
    from("src/conf"){
        into("/conf")
    }
}

This task will copy the files from /src/conf to the /conf folder in the war file.

This post is based on the Gradle Cargo Plugin by bmuschko

Include the Plugin

You need to include the plugin in your build.gradle.

buildscript {
    repositories {
        jcenter()
    }

    dependencies {
        classpath 'com.bmuschko:gradle-cargo-plugin:2.2.3'
    }
}

apply plugin: 'com.bmuschko.cargo'

buildscript block should be the first thing in the build.gradle file.

Include the Gradle Cargo plugin dependencies

Add the following in your gradledependencies block

dependencies {
    def cargoVersion = '1.4.5'
    cargo "org.codehaus.cargo:cargo-core-uberjar:$cargoVersion",
            "org.codehaus.cargo:cargo-ant:$cargoVersion"
}

Define the Tomcat Container

To deploy The war files to Tomcat you need to create a dsl by name cargo and define the mandatory containerId.

Gradle task to deploy war file on Tomcat

Below is a sample gradle task that will deploy war file from given location to Tomcat.

task deployAppA(type: com.bmuschko.gradle.cargo.tasks.remote.CargoRedeployRemote) {
    description = "Deploys WAR to Tomcat ."  // description of task 
    hostname = '127.0.0.1' // ip of the tomcat 
    port = 8080 // port at which tomcat is running
    username = "tomcat" // username of tomcat
    password = "tomcat"  // password of the tomcat
    deployables = [
            new com.bmuschko.gradle.cargo.convention.Deployable(file: file('/path/to/war/appA.war'), context: 'appA')]
}

The above will deploy your war file appA.war on Tomcat running on your local machine.

Adding Manage-Script role to Tomcat

To add the role to Tomcat, go to path-to-tomcat/conf folder and replace the contents of file with the following.

<?xml version='1.0' encoding='utf-8'?>
<tomcat-users>
  <role rolename="manager-script"/>
  <user username="tomcat" password="tomcat" roles="tomcat,manager-script"/>

</tomcat-users>

The above will set a user tomcat with password tomcat and roles tomcat and manager-script.

Now restart your tomcat server and run the gradle task with the command

gradle -q deployAppA

This should deploy your war file to tomcat.

How To Exclude File from a Jar file.

Gradle task Jar has a property excludes which takes an array as an input and exclude these files from the Jar file it creates.

Let's assume the following directory structure

Following example excludes files from the Jar file.

task createExcludingFiles(type :Jar){
    from ('src'){
        excludes = ["main/java/com/ekiras/demo/D.java","main/java/com/ekiras/demo/E.java"]
    }
}

This will exclude files D.java, E.java from the jar file. Run the gradle task using command gradle -q createExcludingFiles. The Jar file created will have the following files.

META-INF/
META-INF/MANIFEST.MF
main/
main/java/
main/java/com/
main/java/com/ekiras/
main/java/com/ekiras/demo/
main/java/com/ekiras/demo/A.java
main/java/com/ekiras/demo/C.java
main/java/com/ekiras/demo/F.java
main/java/com/ekiras/demo/B.java
main/java/com/ekiras/demo/p1/
main/java/com/ekiras/demo/p1/X.java
main/java/com/ekiras/demo/p1/Z.java
main/java/com/ekiras/demo/p1/Y.java
test/
test/java/
main/resources/
test/resources/

Exclude Package in Jar file

task createExcludingPackage(type :Jar){
    from ('src'){
        excludes = ["main/java/com/ekiras/demo/D.java" ,"main/java/com/ekiras/demo/p1/**"]
    }
}

Run the task using command gradle -q createExcludingPackage. This will remove

1. All the files from package p1
2. Class D.java

The Jar file created will have the following files.

META-INF/
META-INF/MANIFEST.MF
main/
main/java/
main/java/com/
main/java/com/ekiras/
main/java/com/ekiras/demo/
main/java/com/ekiras/demo/A.java
main/java/com/ekiras/demo/E.java
main/java/com/ekiras/demo/C.java
main/java/com/ekiras/demo/F.java
main/java/com/ekiras/demo/B.java
test/
test/java/
main/resources/
test/resources/

How to name a Jar file

Lets take the following jar file for explaning the jar naming conventions.

customName_wrapper_2.0.1_SNAPSHOT.jar

A jar file has the following properties

Here property archiveName if specified will override all the other naming conventions like baseName etc. It should be a fully qualified name of the Jar including the extension (.jar)

Other Properties of Gradle Task :: Jar

Creating a Jar file

Let's assume the following directory structure

Create a Jar file with all files.

We can write a gradle task to include all files in src to our jar file as follows

task createAll(type : Jar){
    from 'src'
}

When we run the gradle task as gradle -q createAll will give the following files in the jar

META-INF/
META-INF/MANIFEST.MF
main/
main/java/
main/java/com/
main/java/com/ekiras/
main/java/com/ekiras/demo/
main/java/com/ekiras/demo/D.java
main/java/com/ekiras/demo/A.java
main/java/com/ekiras/demo/E.java
main/java/com/ekiras/demo/C.java
main/java/com/ekiras/demo/F.java
main/java/com/ekiras/demo/B.java
main/java/com/ekiras/demo/p1/
main/java/com/ekiras/demo/p1/X.java
main/java/com/ekiras/demo/p1/Z.java
main/java/com/ekiras/demo/p1/Y.java
test/
test/java/
main/resources/
test/resources/

Create a Jar file from a Package.

task createFromPackage(type : Jar){
    from ("src/main/java/com/ekiras/demo/p1")
}

Run the above task with command gradle -q createFromPackage, it will give the following files in jar.

META-INF/
META-INF/MANIFEST.MF
X.java
Z.java
Y.java

Create a Jar file with Selected Files.

task createSelectedJar(type : Jar){
    from ('src/main/java/com/ekiras/demo'){
        includes = ["A.java","B.java", "p1/X.java", "p1/Y.java"]
    }
}

Run the above command with command gradle -q createSelectedJar

META-INF/
META-INF/MANIFEST.MF
A.java
B.java
p1/
p1/X.java
p1/Y.java

Create a Jar file excluding some files

task createExcludingFiles(type :Jar){
    from ('src'){
        excludes = ["main/java/com/ekiras/demo/D.java","main/java/com/ekiras/demo/E.java", "main/java/com/ekiras/demo/p1/**"]
    }
}

Run the gradle task with command gradle -q createExcludingFiles. It will result in a jar file with the following files

META-INF/
META-INF/MANIFEST.MF
main/
main/java/
main/java/com/
main/java/com/ekiras/
main/java/com/ekiras/demo/
main/java/com/ekiras/demo/A.java
main/java/com/ekiras/demo/C.java
main/java/com/ekiras/demo/F.java
main/java/com/ekiras/demo/B.java
test/
test/java/
main/resources/
test/resources/

To Sum up all the exmaples above

Following is a gradle task that create a jar file

task createJar(type: Jar){
    from ('src/main/java/com/ekiras/demo'){
        includes = ["A.java","B.java", "p1/**"]
        excludes = ["D.java","E.java"]
    }
    baseName = 'customName'
    appendix = 'wrapper'
    version = "2.0.1"
    classifier = 'SNAPSHOT'
    archiveName = "${baseName}_${appendix}_${version}_${classifier}.jar"
    extension  = "ext"
    destinationDir = new File("${buildDir}/test/a")

    manifest {
        attributes = [
                'Main-Class' : "com.ekiras.A",
                'Version'    : 2.0
         ]
    }
}

we can also write a gradle task to see the files that were created inside the jar file as follows

task showFiles(dependsOn : createJar){
    doLast{
        FileTree files = zipTree("${buildDir}/test/a/${archiveName}")
        files.each {
            println "${it.name}"
        }
    }
}

When we run the task gradle -q createJar showFiles or simply gradle -q showFiles , it will give the following result

A.java
B.java
MANIFEST.MF
X.java
Y.java
Z.java

How to load and read files in Gradle Project.

The Gradle Project Api has the following methods for using files.

1. file() - to load and read a particular file
2. files() - to load and read multiple files
3. fileTree() - to load and read file hierarchy in a directory or folder
4. zipTree() - to load and read a zip file (includes Jar , War and Ear files)
5. tarTree() - to load and read a tar file

How to list files inside a Zip file Jar File and Tar file

Lets say we have a file structure as shown in image below.

Following Gradle task will list the files inside a zip file, jar file and a tar file at the location "src/main/resources/archives/"

task showFiles(){
    doLast{
        FileTree zipFiles = zipTree("src/main/resources/archives/resources.zip");
        FileTree jarFiles = zipTree("src/main/resources/archives/resources.jar");
        FileTree tarFiles = tarTree("src/main/resources/archives/resources.tar.gz");

        println " \n#Contents of Zip File"
        zipFiles.each {
            println "${it.name}"
        }

        println " \n#Contents of Jar File"
        jarFiles.each {
            println "${it.name}"
        }

        println " \n#Contents of Tar File"
        tarFiles.each {
            println "${it.name}"
        }
    }
}

When we run the above gradle task using command gradle -q showFiles, it will give the following output.

 
#Contents of Zip File
file1.properties
sample1.txt
sample2txt
 
#Contents of Jar File
file1.properties
sample1.txt
sample2txt
 
#Contents of Tar File
sample1.txt
file1.properties
sample2txt

Read More

• How to Get a File using Relative Path
• How to Get Multiple Files using FileCollection
• How to Get all files in a Directory using FileTree
• Difference between File, FileCollection and FileTree in Gradle

Difference Between File, FileCollection and FileTree in Gradle

Difference Between File, FileCollection and FileTree

Suppose we have a directory structure as shown in image below.

We can write a gradle task as shown below

task loadFiles(){
    doLast{

        File file = file('src/main/resources/sample1.txt')
        println file.name
        println "\n"

        FileCollection collection = files('src/main/resources/sample1.txt','src/main/resources/sample2.txt')
        collection.each {
            println it.name
        }
        println "\n"

        FileTree tree = fileTree('src')
        tree.each {
            println it.name
        }
    }
}

When we run the above gradle task using command gradle -q loadFiles, it will give the following output.

sample1.txt


sample1.txt
sample2.txt


sample1.txt
sample2txt
file1.properties
A.java

Read More

• How to Get a File using Relative Path
• How to Get Multiple Files using FileCollection
• How to Get all files in a Directory using FileTree

Introduction to FileTree in Gradle Api

FileTree is an interface that extends FileCollection and introduces methods like matching() and visit(). It class represents a hierarchy of files in a given directory. It includes files in same folder and all sub folders.

How to get all files in a Directory

To load all files in a given directory and its sub directories you can use FileTree. Syntax for FileTree is as shown below.

FileTree tree = fileTree('path/to/dir')

The FileTree can get files in following ways

1. from relative path
2. from

We can write a gradle task to list all the files in the src folder as shown below.

task loadFiles(){
    doLast{
        FileTree tree = fileTree('src')
        tree.each {
            println it.name
        }
    }
}

When we run the aobe task using command gradle -q loadFiles it will give the following output

sample1.txt
sample2txt
file1.properties
A.java

Introduction to FileCollection

FileCollection is an interface that extends Iterable<File>, AntBuilderAware and Buildable interfaces.

How to load files in a FileCollection

Suppose we have a file structure as shown in image below

We can load multiple files for operation using the following syntax

FileCollection collection = files('relative/path/file1','absolute/path/file2',new File('file3'))

As shown in the example above we can load files in three ways

1. From a relative path
2. From a absolute path
3. From a File object.

We can write a gradle task to read all files in a folder or directory as follows

task fileTree(){
    doLast{
        FileTree tree = fileTree('src')
        tree.each {
            println it.name
        }
    }
}

Now when we run the above gradle task with the command gradle -q fileTree, it will give the following output

sample1.txt
sample2txt
file1.properties
resources.tar.gz
resources.jar
resources.zip
A.java

Operations and methods available for FileCollection

1. getSingleFile() - It returns a single file. (it will throw IllegalStateException if files contains more than one file or no file)
2. getAsFileTree() - It returns the FileCollection as a FileTree.
3. plus(FileCollection collection) - It will add the specified file collection to the existing file collection.
4. minus(FileCollection collection) - It will remove from the collection files in specified collection.
5. filter(Closure filter) - It will filter the files from collection and make changes to the same collection.

Read More

• How to Get a File using Relative Path
• How to Get Multiple Files using FileCollection
• How to Get all files in a Directory using FileTree
• Difference between File, FileCollection and FileTree in Gradle

How to read a file in Gradle Task

To load a file, you can take following three approaches

1. Load file using relative path

   File file = file('relative/path/file')
   

2. Load file using absolute path

   File file = file('absolute/path/file')
   

3. Load a file using File object

   File file = file(new File('somePath'))
   

Lets see how these three approaches work

task loadFiles << {
   println file('src/main/resources/file1.properties')
   println file('/home/ekiras/workspace/tutorials/gradle/src/main/resources/file1.properties')
   println file(new File('src/main/resources/file1.properties'))

}

When we run the above task using command gradle -q loadFiles it will give the following output

/home/ekiras/workspace/tutorials/gradle/src/main/resources/file1.properties
/home/ekiras/workspace/tutorials/gradle/src/main/resources/file1.properties
/home/ekiras/workspace/tutorials/gradle/src/main/resources/file1.properties

How to read a File in gradle task

Say, we have a file sample.txt in src/main/resources folder with the following context

I am some awesome text line 1
I am some awesome text line 2

Lets read this file in a gradle task.

task readFile(){
    doLast{
        File file = file('src/main/resources/sample.txt')
        println file.text
        println ""
        file.readLines().each{
            println it
        }

    }
}

Now when we run the command gradle -q readFile we will get the following output.

I am some awesome text line 1
I am some awesome text line 2

I am some awesome text line 1
I am some awesome text line 2

Read More

• How to Get a File using Relative Path
• How to Get Multiple Files using FileCollection
• How to Get all files in a Directory using FileTree

How to check if the operation system is Windows, Linux or Mac Os.

org.gradle.internal.os.OperatingSystem is an interface in gradle. This interface provides methods to get th einformation about the operating system.

This interface provides the following method to get the information about the operating system.

task osInfo(){
    doLast{
        println OperatingSystem.current();
        println OperatingSystem.current().name;
        println OperatingSystem.current().isLinux();
        println OperatingSystem.current().isMacOsX();
        println OperatingSystem.current().isWindows();
    }
}

When we run the task with the command gradle -q osInfo it will give the following information.

:osInfo
Linux 4.4.0-51-generic amd64
Linux
true
false
false

BUILD SUCCESSFUL

Total time: 0.68 secs

How to write a Gradle Task

A gradle task can be written in the following two ways

task hello(){
  doLast(){
    println "Hello World"
  }
}

Or you can write a task as follows

task hello << {
   println "Hello World"

}

Here in example 2, << operator is simply an alias for doLast.

Write a Gradle Task that depends on another Gadle Task

Lets take an example of the following gradle file.

build.gradle

task openFile(){
    doLast{
        println "Open file"
    }
}

task readFile(dependsOn : 'openFile'){
    doLast{
        println "Read File"
    }
}

task closeFile(dependsOn : ['openFile','readFile']){
    doLast{
        println "Close File"
    }
}

Here in this example, we have three tasks

1. openFile - that will open a file
2. readFile - that will read a file
3. closeFile - that will close a file.

Now, for able to read from a file, we should first open a file, so readFile depends on openFile, also a file will be closed after reading a file so closeFile task depends on both openFile and readFile

Now if we run the tasks, it will give the following outputs

> gradle -q openFile or gradle -q oF
> Open file

> gradle -q readFile or gradle -q cF
> Open file
> Read File

gradle -q closeFile or gradle -q cF
> Open file
> Read File
> Close File

A gradle task is loaded in a lazy manner that means you can define a task anywhere in the build file. The task dependency is looked in execution phase and not in configuration phase.

Let's check it by the following example

// Task B does not exists here but will be resolved at runtime.
task A(dependsOn : 'B'){ 
  doLast(){
    println "A"
  }
}

task B(){
  doLast(){
    println "B"
  }
}

Also Read

• Introduction to Gradle
• Gradle task Short hand notations
• How to run a specific gradle task or multiple tasks
• Difference between doFirst() and doLast() methods
• What is a Gradle Daemon

What is a Gradle Task alias

Suppose we have a gradle file as below

build.gradle

task copyAllFiles(){
    doLast{
        println "copyAllFiles"
    }
}

task copySomeFiles(){
    doLast{
        println "copyAllFiles"
    }
}

task copyParticularFiles(){
    doLast{
        println "copyAllFiles"
    }
}

Now to run the above tasks we have to run the following commands

gradle -q copyAllFiles
gradle -q copySomeFiles
gradle -q copyParticularFiles

However we can also run the gradle tasks by unique names that diffrenetiates the tasks for example

gradle -q cAF // short form for copyAllFiles
gradle -q cSF // short form for copySomeFiles
gradle -q cPF // short form for copyParticularFiles

but if we run a task with a short name that does not uniquely define a task then it will trow an exception. for example

gradle -q copy

will throw the execption

FAILURE: Build failed with an exception.

* What went wrong:
Task 'copy' is ambiguous in root project 'Gradle Tutorial'. Candidates are: 'copyAllFiles', 'copyParticularFiles', 'copySomeFiles'.

Also note, that the characters used for short form are case sensitive, so cAF will run the task copyAllFiles but caf will not.

What is a Gradle Default task ?

In gradle, we can have default tasks. A default task is a task that will run if no task is specified. We can define any task a gradle default task using the following

defaultTasks 'task1','task2'

The defaultTasks takes a list of tasks as a parameter. These tasks will be run if no task is specidied to run.

build.gradle

defaultTasks 'banner','attribution'

task banner(){
    doLast {
        println "______ _    _";
        println "|  ____| |  (_)"
        println "| |__  | | ___ _ __ __ _ ___   ___ ___  _ __ ___"
        println "|  __| | |/ / | '__/ _` / __| / __/ _ \\| '_ ` _ \\"
        println "| |____|   <| | | | (_| \\__ \\| (_| (_) | | | | | |"
        println "|______|_|\\_\\_|_|  \\__,_|___(_)___\\___/|_| |_| |_|"


    }
}
task attribution(){
    doLast {
        println "Developed by :: Ekansh Rastogi"
    }
}

Default tasks will be run in the following two cases. In both the cases we have not specified the tasks that we need to run.

1. gradle 
2. gradle -q

It will give the following output.

:banner
______ _    _
|  ____| |  (_)
| |__  | | ___ _ __ __ _ ___   ___ ___  _ __ ___
|  __| | |/ / | '__/ _` / __| / __/ _ \| '_ ` _ \
| |____|   <| | | | (_| \__ \| (_| (_) | | | | | |
|______|_|\_\_|_|  \__,_|___(_)___\___/|_| |_| |_|
:attribution
Developed by :: Ekansh Rastogi

How to run a specific gradle task

When you want to run a particular task only then you can run that task using the following command.

gradle -q <task-name>

-q option tells gradle that you want to run only the tasks that are provided. In this example we have instructed gradle to run only one task

How to run multiple gradle tasks

Multilple gradle tasks can be run using the following syntax.

gradle -q <task-name> <task-name> <task-name>

In second example we have told gradle to run 3 tasks, they are run in the order they are provided. However if one of the task is dependent on any other task, then that task will execute first. Also A task is run only one time even if it is specified multiple times.

For example if we have the following tasks in build.gradle

task A {
    doLast {
        println 'Running task A'
    }

    doFirst{
        println(" Pring first")
    }
}

task B(dependsOn: A) {
    doLast {
        println 'Running task B'
    }
}

task C(dependsOn: [A, B]) {
    doLast {
        println 'Running task C'
    }
}

and we run the tasks using the following command.

gradle B A C

Then the gradle tasks will be executed in this manner First A will execute then B and finally C will execute.

READ MORE

• Introduction to Gradle
• Difference between doFirst() and doLast() methods

Point to Remember

1. doFirst() and doLast() are the methods of org.gradle.api.Task interface.
2. Both these methods take a Closure as a parameter.
3. When a task is called this closure is called.

A Gradle task is sequence of Action objects and when a task is run all these actions are called in a sequence by calling Action.execute(T)

What are doFirst() and doLast() methods in a Gradle task.

doFirst(Closure action)

This method will add your closure as an action to the beginning of the action sequence. All the code that is written in this closure is executed first when the task is executed.

doLast(Closure action)

This method will add your closure as an action to the end of the action sequence. All the code in this closure is executed in last when the task is executed.

Let's take a look at the following example.

task A {
    doLast {
        println("Running task A :: LAST")
    }

    doFirst{
        println("Running task A :: FIRST ")
    }
}

When we run this task using command gradle -q A the following is the output of the command.

Running task A :: FIRST 
Running task A :: LAST

NOTE

Any code that is written outside these two methods will be executed every time, even if some other task is run.

For example, if we write our task in the following way and run

task A {
    println(" print statement 1")
    doLast {
        println("Running task A :: LAST")
    }
    println(" print statement 2")

    doFirst{
        println("Running task A :: FIRST ")
    }
    println(" print statement 3")
}

It will give the following output

 print statement 1
 print statement 2
 print statement 3
Running task A :: FIRST 
Running task A :: LAST

How to continue a build even if a failure occurs

Many a times there is a need to continue running a build process even if some of the tasks fails. To run a build even if the some of the tasks fail we can use the --continue switch.

1. It will execute all tasks even if some of them fails. Normal behavior is that build stops as soon as first failure is encountered.
2. It will show the report of encountered failures at the end of the build.
3. When a task fails all the tasks that depends on this task will not be executed. This is because, if compilation fails then, there is no point of packaging the project.

Now lets take see a few examples

build.gradle

group 'com.ekiras'
version '1.0-SNAPSHOT'

apply plugin: 'java'

sourceCompatibility = 1.8

repositories {
    mavenCentral()
}


dependencies {
    testCompile group: 'junit', name: 'junit', version: '4.11'
}

task failure(){
    doLast{
        println " I am going to fail now"
        throw new RuntimeException("I am failing somewhere");
    }
}

Now lets run the tasks using gradle failure build. It will fail and not execute the task build because failure task has failed. See complete logs below

:failure
 I am going to fail now
:failure FAILED

FAILURE: Build failed with an exception.

* Where:
Build file '/home/ekiras/workspace/tutorials/gradle/build.gradle' line: 22

* What went wrong:
Execution failed for task ':failure'.
> I am failing somewhere

* Try:
Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log output.

BUILD FAILED

Total time: 0.626 secs

Now lets say we want to build even if the failure task fails, so we can do so by command gradle failure build --continue. it will give the following logs.

:failure
 I am going to fail now
:failure FAILED
:compileJava UP-TO-DATE
:processResources UP-TO-DATE
:classes UP-TO-DATE
:jar UP-TO-DATE
:assemble UP-TO-DATE
:compileTestJava UP-TO-DATE
:processTestResources UP-TO-DATE
:testClasses UP-TO-DATE
:test UP-TO-DATE
:check UP-TO-DATE
:build UP-TO-DATE

FAILURE: Build failed with an exception.

* Where:
Build file '/home/ekiras/workspace/tutorials/gradle/build.gradle' line: 22

* What went wrong:
Execution failed for task ':failure'.
> I am failing somewhere

* Try:
Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log output.

BUILD FAILED

Total time: 0.595 secs

The difference between the two logs in example is that, in first example execution terminated at the failure task and build task was never executed. However in example 2, even when the failure task failed, build task was executed.

What is a Gradle Task.

Lets first create a gradle file build.gradle with the following contents in it.

group 'com.ekiras'
version '1.0-SNAPSHOT'

apply plugin: 'java'

sourceCompatibility = 1.8

repositories {
    mavenCentral()
}

dependencies {
    testCompile group: 'junit', name: 'junit', version: '4.11'
}

Now, lets run the the following command from terminal in the root directory where build.gradle is saved.

gradle tasks

It will give the list of all the tasks that are defined. It includes both gradle default tasks and custom tasks.

Now, you can run any defined task using the command.

gradle <task-name>

How to write a Custom Task in Gradle.

1. A task in gradle is an imlpementation of org.gradle.api.Task interface.
2. Task interface has two methods doLast() and doFirst() which can define the order of task execution.
   • doFirst(Closure action) - This adds the given closure to the beginning of this task's action list.
   • doLast(Closure action) - This adds the given Action to the end of this task's action list.
3. Other useful methods are
   • getName() - returns the name of the task
   • getPath() - returns the fully qualified path of the task
   • mustRunAfter(Object... paths) - task should run after the given tasks
   • setGroup(String group) - Adds the task to a specified group.
   • setDependsOn(Iterable<?> dependsOnTasks) - set a list of tasks this task depends on.

You can see Full List of Methods in Task interface in the official documents.

Syntax for writing a task is as follows.

// Simple Task
task core(){
  // do stuff
}

// Task which depends on some other task

task main(dependsOn : 'core'){
   // do stuff
}

So we can write the tasks as follows.

task A {
    doLast {
        println 'Running task A'
    }
}

task B(dependsOn: A) {
    doLast {
        println 'Running task B'
    }
}

task C(dependsOn: [A, B]) {
    doLast {
        println 'Running task C'
    }
}

task D(dependsOn: [A, C]) {
    doLast {
        println 'Running task D'
    }
}

1. We can run any task using command gradle <task-name>.
2. To run multipe tasks in one step you can use command gradle <task-name> <task-name> <task-name>. It will run the tasks in the defined list specified.

Note

gradle <task-name> <task-name> <task-name> will only trigger tasks in this order, but task run list is still defined by tasks definitions that is if a tasks depends on any other task then taht task will be executed first. Also a task is run only once even if it is defines many times. gradle A A A is equivalent to gradle A.

How to Import Gradle file in another gradle file.

To import a gradle file in a gradle file you can use the following command in .gradle.

We have a gradle file build.gradle and we are including two other gradle files tasks.gradle and test.gradle.

apply from : 'tasks.gradle'
apply from : 'https://ekiras.github.io/temp/test.gradle'

Here, in line 1, we have imported tasks.gradle which lies in the same directory as build.gradle and in line 2 we have imported a test.gradle from a remote server. (Git hub pages in this case, it can be an s3 url or your server file url)

Test Imported gradle file task

build.gradle has the following content

group 'com.ekiras'
version '1.0-SNAPSHOT'

apply plugin: 'java'
apply from : 'tasks.gradle'
apply from : 'https://ekiras.github.io/temp/test.gradle'

sourceCompatibility = 1.8

repositories {
    mavenCentral()
}

dependencies {
    testCompile group: 'junit', name: 'junit', version: '4.11'
}

tasks.gradle has the following contents

task hello{
    println "Hello World"
}

We can now run the task hello with the following command

gradle -q hello

It will give the following output.

Hello World