Gradle - the Enterprise Automation Tool

Gradle
The
Enterprise Automation
Tool

● SA at EPAM Systems
● primary skill is Java
● hands-on-coding with Groovy, Ruby
● exploring FP with Erlang/Elixir
● passionate about agile, clean code and devops

Agenda
● Introduction
● Gradle
● Step by step by features
● Alternatives
● References
● Q&A

Principles
#1 Each change auto. built and deployed

#2 Test on closed to prod environment
Principles

#3 Integrate as frequently as possible
Principles

#3 Integrate as frequently as possible
Principles
#4 The highest priority is to fix failed build

Benefits
● Each change guarantees working code
● Each update should guarantee working
code ;)
● There is no delay for epic merge
● Less bugs - depends on your tests
efficiency*
● Allows to have code ready to go live

Challenges
● Need to build infrastructure
● Need to build team culture
● Need to support/enhance infrastructure
● Overhead with writing different kinds of
tests

Principles
#1 Every commit should result in a release

Principles
#2 Automated tests are essential

Principles
#3 Automate everything!

Principles
#3 Automate everything!
#4 Done means release/live in prod

Benefits
● Speed of delivery of business idea to
customer
● Easy going live deployment
● Less time spent on delivery - more profit
● More motivation to do more as you can
see what you can change/improve

Challenges
● Big effort to implement changes for:
○ database increment/rollback
○ infrastructure rollout/rollback
○ decrease down time …
● Need to get customers to buy in
● Security policies

Gradle
- General purpose build system

Gradle
- Comes with a rich DSL based on Groovy

Gradle
- Follows ”build-by-convention” principles

Gradle
- Built-in plug-ins for JVM languages, etc

Gradle
- Built-in plug-ins for JVM languages, etc
- Derives all the best from Ivy, Ant & Maven

1. JDK 8
2. Gradle 2.2+
3. Git
Prerequisites

1. Change directory to D:ImagesGradle folder
2. Open Command Window in dir D:ImagesGradle
3. Execute
Gitbingit clone
https://github.com/webdizz/sbs-gradle.git
4. Change directory to sbs-gradle
5. Execute
set_env.bat
gradle -v
java -version
#0 Installation

1. Reset code base to initial state
git reset --hard 3a2ed47
git clean -df
2. Create file build.gradle
3. Type
println 'Hello, World!'
4. Run
gradle
#1 Hello World!

1. Run to see default tasks list
gradle tasks
2. Replace build.gradle file content with
apply plugin: 'java'
3. Run to see new available tasks
gradle tasks
4. Checkout step s3_apply_plugin
5. Run to build Java source code
gradle build
6. Explore directory build
#2 Create simple build

1. Run task with part of name
gradle ta
2. Run task with part of name to clean and compile
gradle cle tC
3. Run task with part of name to clean and compile and
exclude processTestResources
gradle cle tC -x pTR
4. Get details for task
gradle -q help --task clean
#3 Execute tasks

1. Run task
gradle tasks
2. Run task to generate wrapper
gradle wrapper
3. Run tasks using wrapper
./gradlew tasks
4. Customize task wrapper to use another Gradle version
task wrapper(type: Wrapper) {
gradleVersion = '2.2.1'
}
5. Check Gradle version
./gradlew -v
#4 Use wrapper

1. Checkout step s5_prepare
2. Add directory common
3. Move src to common
4. Create common/build.gradle for Java
5. Add new module to settings.gradle
include ':common'
6. Run build
./gradlew clean build
7. Run task for module
./gradlew :com:compJ
#5 Create multi-module build

Gradle
- compile - to compile source

Gradle
- runtime - required by classes at runtime

Gradle
- testCompile - to compile test sources

Gradle
- testCompile - to compile test sources
- testRuntime - required to run the tests

1. Add repositories to download dependencies from to
build.gradle
allprojects { currProject ->
repositories {
mavenLocal()
mavenCentral()
jcenter()
maven {url 'http://repo.mycompany.com/’}
}
}
#6 Dependencies

1. Add common dependencies for all subprojects in
build.gradle
subprojects {
apply plugin: 'java'
dependencies {
compile 'org.slf4j:slf4j-api:1.7.7'
testCompile
'org.mockito:mockito-core:1.10.19',
'junit:junit:4.12'
}
}
#6.1 Dependencies

1. Add dependencies for concrete module in
common/build.gradle
dependencies {
compile
'org.projectlombok:lombok:1.14.4'
}
#6.2 Dependencies

1. List project dependencies
./gradlew :common:dependencies
#6.3 Dependencies

1. Extract common configuration parameters to gradle
.properties file
lombokVersion = 1.14.4
build.gradle file
dependencies {
compile
“org.projectlombok:lombok:$lombokVersion”
}
#7 Configuration

1. Parameterise execution for custom task :printParameter
in build.gradle
task printParameter {
println givenParameter
}
2. Add parameter default value to gradle.properties
3. Execute task
./gradlew -q :printParameter -PgivenParameter=hello
#7.1 Configuration

● Lifecycle
● Create a Settings instance for the build.
● Evaluate the settings.gradle script, if present, against the Settings
object to configure it.
● Use the configured Settings object to create the hierarchy of Project
instances.
● Finally, evaluate each Project by executing its build.gradle file, if
present, against the project. The project are evaluated in such order
that a project is evaluated before its child projects.

● Tasks
● A project is essentially a collection of Task objects.
● Each task performs some basic piece of work.
● Dependencies
● A project generally has a number of dependencies.
● Project generally produces a number of artifacts, which other projects
can use.

● Plugins
● Plugins can be used to modularise and reuse project configuration.
● Properties
● Any property or method which your script uses is delegated through to
the associated Project object.
● A project has 5 property 'scopes'.
● Dynamic Methods
● A project has 5 method 'scopes'.

1. Add integration test source sets in file
gradle/integTest.gradle
sourceSets {
integTest {
compileClasspath += main.output + test.output
runtimeClasspath += main.output + test.output
}
}
#8.1 Rich API

2. Add integration test configurations in file
gradle/integTest.gradle
configurations {
integTestCompile.extendsFrom testCompile
integTestRuntime.extendsFrom testRuntime
}
3. Include extension for subprojects in file build.gradle
apply from:
file("${rootProject.projectDir}/gradle/integ
Test.gradle")
#8.1 Rich API

3. Add integration test task in file gradle/integTest.gradle
task integTest(type: Test){
testClassesDir =
sourceSets.integTest.output.classesDir
classpath =
sourceSets.integTest.runtimeClasspath
shouldRunAfter 'test'
}
check.dependsOn(integTest)
4. Execute integration tests
./gradlew integTest
#8.1 Rich API

1. Open build.gradle to add dependency for one task
from another
printParameter.dependsOn 'help'
2. Run printParameter task
./gradlew printParameter
#8.2 Tasks Dependencies

1. Open build.gradle to add ordering for one task from
another
task areTestsExist {
if ([
file("${projectDir}/src/test/java").listFiles()
].isEmpty()) {
println 'Test directory is empty'
} else {
println 'Test directory is not empty, will
execute tests'
}
}
test.mustRunAfter areTestsExist
#8.3 Tasks Ordering*

2. Run test task
./gradlew test
#8.3 Tasks Ordering*

1. Add rule to validate running of integration tests task
tasks.addRule('Check correctness of running tests'){ String
taskName ->
gradle.taskGraph.whenReady{
Map<String, String> args =
gradle.startParameter.systemPropertiesArgs
gradle.taskGraph.allTasks.each { Task task ->
if (task.name.contains('integTest') &&
!args.containsKey('profile')) {
throw new
org.gradle.api.tasks.StopExecutionException("Profile was not
specified to run tests (-Dprofile=ci).")
}
}
}
}
#8.4 Rules

2. Run check task to have failure
./gradlew check
3. Run check task with expected parameter
./gradlew check -Dprofile=ci

#8.4 Rules

1. Switch to 9th step and execute next command
./gradlew test --parallel
2. Try to modify amount of executable threads
./gradlew test --parallel --parallel-threads=3

#9 Parallel builds

1. Create file gradle/releaseNotes.gradle to add task for
release notes
ext.destDir = new File(buildDir, 'releaseNotes')
ext.releaseNotesTemplate = file('releaseNotes.tmpl.txt')
tasks.create(name: 'copyTask', type: org.gradle.api.tasks.Copy) {
from releaseNotesTemplate
into destDir
doFirst {
if (!destDir.exists()) {
destDir.mkdir()
}
}
rename { String fileName ->
fileName.replace('.tmpl', '')
}
}
#10 Custom Inputs/Outputs

tasks.create('releaseNotes') {
inputs.file copyTask
outputs.dir destDir
}
2. Add releaseNotes.tmpl.txt file as a template for release
notes
3. Apply configuration from gradle/releaseNotes.gradle in
build.gradle
4. Let’s run releaseNotes task
./gradlew releaseNotes
#10 Custom Inputs/Outputs

1. Enhance release notes task to prepare nice release notes file

ext.changesFile = file('changes.txt')
ext.bugs = []
ext.features = []
changesFile.eachLine { String line ->
String bugSymbol = '#bug:'
String featureSymbol = '#feature:'
if (line.contains(bugSymbol)) {
bugs << line.replace(bugSymbol, '')
} else if (line.contains(featureSymbol)) {
features << line.replace(featureSymbol, '')
}
}
filter(org.apache.tools.ant.filters.ReplaceTokens,
tokens: [bugs: bugs.join("n"),
features: features.join("n")])
#10.1 Files filtering

1. Add JaCoCo configuration in gradle/coverage.gradle
apply plugin: "jacoco"
jacoco {
toolVersion = "0.7.7.201606060606"
}
check.dependsOn jacocoTestReport
jacocoTestReport {
dependsOn 'test'
reports {
xml.enabled true
csv.enabled false
html.enabled true
}
}
#11 Test Coverage

2. Apply configuration from gradle/coverage.gradle in
build.gradle
3. Implement proper test for proper method
4. Let’s run check task to collect coverage metrics
5. Open
common/build/reports/jacoco/test/html/index.html file
to overview coverage
#11 Test Coverage

1. Add JaCoCo configuration in gradle/coverage.gradle for
integration tests
task jacocoIntegrationTestReport(type: JacocoReport) {
dependsOn integTest
sourceSets sourceSets.main
executionData integTest
reports {
xml {
enabled true
destination
"$buildDir/reports/jacoco/integTest/jacocoIntegTestReport.xml"
}
csv.enabled false
html {
destination "$buildDir/reports/jacoco/integTest/html"
}
}
}
#11.1 Integration Test Coverage

check.dependsOn jacocoIntegrationTestReport
jacocoIntegrationTestReport.mustRunAfter jacocoTestReport
2. Let’s run check task to collect coverage metrics for
integration tests as well

#11.1 Integration Test Coverage

Ad-hoc,
fast
feedback
Over
time

1. Add configuration in gradle/codeQuality.gradle for code
quality analysis and apply configuration in build.gradle
subprojects {
apply plugin: 'findbugs'
findbugs {
ignoreFailures = true
toolVersion = '3.0.0'
}
apply plugin: 'pmd'
pmd {
toolVersion = '5.1.3'
}
}

#12 Static Code Analysis

2. Let’s run check task to collect code quality metrics
3. Open common/build/reports/pmd|findbugs/*.html

#12 Static Code Analysis

1. Add configuration in gradle/publishing.gradle for artefacts
publishing and apply configuration in build.gradle
apply plugin: 'maven-publish'
publishing {
repositories {
maven {
url
"http://artifactory.vagrantshare.com/artifactory/libs-release-local"
credentials {
username 'admin'
password 'password'
}
}
}
publications {
mavenJava(MavenPublication) {
groupId "name.webdizz.${rootProject.name}"
version = uploadVersion
from components.java
}
}
}
#13 Artefacts Publishing

2. Let’s run publish task to publish artefacts
./gradlew publish -PuploadVersion=1.1.1.[YourName]
3. Check artefact was uploaded at
http://artifactory.vagrantshare.com/artifactory

#13 Artefacts Publishing

● Build script
Visible for build file
● buildSrc/src/main/groovy
Visible for project
● Standalone project
Could be shared between projects using binary artefact

1. Create file PluginsPrinterPlugin.groovy in
buildSrc/src/main/groovy
import org.gradle.api.Plugin
import org.gradle.api.Project
public class PluginsPrinterPlugin implements Plugin<Project> {
void apply(Project project) {
project.task('printPlugins') << {
println 'Current project has next list of plugins:'
ext.plugins = project.plugins.collect { plugin ->
plugin.class.simpleName
}
println plugins
}
}
}
#14 Plugins Printer

2. Apply plugin for all projects in build.gradle file
allprojects {
apply plugin: PluginsPrinterPlugin
}
3. Let’s run printPlugins task to print plugins activated for
project
./gradlew printPlugins

#14 Plugins Printer

- a software
project
management
and
comprehension
tool

● http://www.gradle.org/
● http://www.gradle.org/books
● https://plugins.gradle.org/
● http://groovy-lang.org/
● https://github.com/webdizz/sbs-gradle
● https://nebula-plugins.github.io/
References

Izzet Mustafayev@EPAM Systems
@webdizz webdizz izzetmustafaiev
http://webdizz.name

Gradle - the Enterprise Automation Tool

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to Gradle - the Enterprise Automation Tool

Similar to Gradle - the Enterprise Automation Tool (20)

More from Izzet Mustafaiev

More from Izzet Mustafaiev (20)

Recently uploaded

Recently uploaded (20)

Gradle - the Enterprise Automation Tool