Gradle plugin, take control of the build

@YourTwitterHandle#YourSessionHashtag
Plugin Gradle, prenez le contrôle du build !

Eyal LEZMY
http://eyal.fr
Cedric CHAMPEAU
@CedricChampeau

SLIDES
bit.ly/gradle-plugin-devoxx

A dependency management
engine
A dependency based execution
system
A plugin system
A set of plugins
DEFINITIONS
What is
Gradle?
by Luke Daley, Gradle core
developer

Build scripts
Your build.gradle file
Script plugins
The customization you start writing
Binary plugins
The code I want you to write
DEFINITIONS
Gradle
Plugins
Types

Is a piece of work for a build
Compiling a class, generating javadoc, ...
Can be manipulated
doFirst, doLast
Can inherit from another
type
Can depend on another task
dependsOn, finalizedBy
DEFINITIONS
The Gradle
Task

Your unit
tests results,
you have to
version
THE SUBJECT

THE JOB
Copy and version this folder

task archiveTests (type: Copy) {
from "$reportsDir/reports"
into "$projectDir/reports/report-${currentTimeMillis()}"
}
tasks.test.finalizedBy archiveTests
THE CODE
End of build.gradle

}
THE CODE
We create the task
End of build.gradle

}
THE CODE
It inherits from Copy task
End of build.gradle

}
THE CODE
We define the copy parameters
End of build.gradle

}
THE CODE
We define the copy parameters
This is the versioningEnd of build.gradle

}
THE CODE
We ask to run it after test task
End of build.gradle

A PLUGIN?
Use it on different projects
Share it with others
Keep your build script clean
Keep your build script focused
Cause’ it’s so easy!
Why a
plugin?

Is a Gradle project
Basically, a Groovy project
It contains
A build.gradle
A plugin class
A descriptor
One or several tasks
An extension
Examples
Java, Groovy, Maven, Android plugin
A PLUGIN?
The Binary
Plugin

THE ARCHITECTURE
The plugin class

THE ARCHITECTURE
The plugin class
A task

THE ARCHITECTURE
The plugin class
A task
The extension

THE ARCHITECTURE
The plugin class
A task
The extension
The descriptor

THE ARCHITECTURE
The plugin class
A task
The extension
The descriptor
The build.gradle

class ArchiveTestsPlugin implements Plugin<Project> {
void apply(Project project) {
//TODO create the extension
//TODO create the tasks
//TODO link the tasks to the build chain
}
}
THE CODE
The Plugin class

//create the extension
project.extensions.create(“achivetest”,ArchiveTestPluginExtension,
project)
//create the tasks
project.task(name:“achivetest”, type:ArchiveTask){}
//link the tasks to the build chain
Task task = project.tasks.getByName(project.archivetest.task)
task.finalizedBy “achivetest”
}
}
THE CODE
The Plugin class

class ArchiveTask extends Copy {
ArchiveTask(){
from project.archivetest.from
into project.archivetest.into
}
@TaskAction
def exec() {
println "Reports copied into ${project.archivetest.into}"
}
}
THE CODE
The Task class

ArchiveTask(){
}
@TaskAction
def exec() {
}
}
THE CODE
We want a Copy task.
Use DefaultTask to implement your ownThe Task class

ArchiveTask(){
}
@TaskAction
def exec() {
}
}
THE CODE
The Task class
Here we use the
extension’s content

archivetest {
from "origin/folder"
into "destination/folder"
task "taskToLaunchCopy"
}
THE CODE
The Extension: the syntax expected

THE CODE
The Extension class
class ArchiveTestPluginExtension {
def from
def into
def task
ArchiveTestPluginExtension(Project project) {
from = project. reportsDir
into = project.projectDir+"/reports/report-${currentTimeMillis()}"
task = "test"
}
}

THE CODE
The Extension class
def from
def into
def task
from = project. reportsDir
task = "test"
}
}
This is a simple POGO

THE CODE
The Extension class
def from
def into
def task
from = project.reportsDir
task = "test"
}
}

implementation-class= main.groovy.fr.eyal.ArchiveTestPlugin
THE CODE
The Descriptor: achivetest.properties

implementation-class=main.groovy.fr.eyal.ArchiveTestPlugin
THE CODE
The name of this file implies
apply plugin: “archivetest”
The Descriptor: achivetest.properties

apply plugin: 'groovy'
dependencies {
compile gradleApi()
compile localGroovy()
}
...
THE CODE
The build.gradle (1/2)

dependencies {
compile gradleApi()
}
...
THE CODE
The build.gradle (1/2) A plugin is a groovy project

dependencies {
compile gradleApi()
}
...
THE CODE
Add a gradle API dependency corresponding
to the gradle version used to compile the
project

dependencies {
compile gradleApi()
}
...
THE CODE
Add a groovy dependency corresponding to
the gradle version used

...
apply plugin: 'maven-publish'
group = 'fr.eyal'
version = '0.1'
publishing {
publications {
mavenJava(MavenPublication) {
from components.java
}
}
}
THE CODE

USE THE PLUGIN
Add the repository
Add dependency
Apply the plugin
Configure the plugin if needed
How to use
our plugin?

buildscript {
repositories {
mavenLocal()
}
dependencies {
classpath 'fr.eyal:archivetest:0.1'
}
}
apply plugin: 'archivetest'
archivetest {
from "build/report"
into "/tmp/archives"
task “connectedAndroidTest”
}
THE CODE
The user’s build.gradle

buildscript {
repositories {
mavenLocal()
}
dependencies {
}
}
archivetest {
from "build/report"
}
THE CODE
The user’s build.gradle The local repository folder

buildscript {
repositories {
mavenLocal()
}
dependencies {
classpath ' fr.eyal:archivetest:0.1'
}
}
archivetest {
from "build/report"
}
THE CODE
pom.group pom.artifactId pom.version

buildscript {
repositories {
mavenLocal()
}
dependencies {
}
}
apply plugin: ' archivetest'
archivetest {
from "build/report"
}
THE CODE
archivetest.properties

buildscript {
repositories {
mavenLocal()
}
dependencies {
}
}
archivetest {
from "build/report"
}
THE CODE
Our extension

archivetest {
from "build/report"
}
RUN IT
$ gradle test

archivetest {
from "build/report"
}
RUN IT
$ gradle test
...
Reports copied into /home/user/project/reports/report-1422480068261
...
BUILD SUCCESSFUL

archivetest {
from "build/report"
}
RUN IT
$ gradle test
...
Reports copied into /home/user/project/reports/report-1422480068261
...
BUILD SUCCESSFUL
Yay!

RUN IT
archivetest {
from "build/report"
task "hello"
}
task hello << {
println "Sample task"
}

RUN IT
archivetest {
from "build/report"
task "hello"
}
task hello << {
}
Copy after the hello task

RUN IT
archivetest {
from "build/report"
task "hello"
}
task hello << {
}
Copy after the hello task
Create the hello task

$ gradle hello
archivetest {
from "build/report"
task "hello"
}
task hello << {
}
RUN IT

RUN IT
$ gradle hello
...
BUILD SUCCESSFUL
archivetest {
from "build/report"
task "hello"
}
task hello << {
}
No copy

RUN IT
$ gradle hello
...
BUILD SUCCESSFUL
archivetest {
from "build/report"
task "hello"
}
task hello << {
}
Oh no...

archivetest {
from "build/report"
task "hello"
}
task hello << {
}
DEBUG IT

archivetest {
from "build/report"
task "hello"
}
task hello << {
}
DEBUG IT
Call apply() on ArchiveTestPlugin

archivetest {
from "build/report"
task "hello"
}
task hello << {
}
DEBUG IT
- Create the extension
- archivetest.task = "test"
- Create the copy task
- Finalize archivetest.task by achivetest task

archivetest {
from "build/report"
task "hello"
}
task hello << {
}
DEBUG IT
Modify the extension content
- archivetest.task = "hello"

archivetest {
from "build/report"
task "hello"
}
task hello << {
}
DEBUG IT
Create the hello task
Modify the extension content
- archivetest.task = "hello"

THE TASK GRAPH
Created by Java/Groovy plugin
test

THE TASK GRAPH
Created by archivetest plugin
test test
archive
test

THE TASK GRAPH
‘test’ finalized by ‘archivetest’
test test
archive
test

THE TASK GRAPH
test test
archive
test
test
archive
test
Created by build.gradle
hello

THE TASK GRAPH
test
archive
test
hello Launch hello

THE TASK GRAPH
test
archive
test
hello Launch hello
No link to our copy task

project)
//create the tasks
}
}
DEBUG IT
The Plugin class

project)
//create the tasks
}
}
DEBUG IT
The Plugin class
Executed too early

DEBUG IT
Initialization
Choose project(s) to build
Configuration
Execute build.gradle
Build task graph
Execution
Execute tasks chain
Gradle
build
lifecylcle

DEBUG IT
Project evaluation
beforeEvaluate
afterEvaluate
Task Graph
whenTaskAdded
whenReady
beforeTask
afterTask
The
lifecycle
events

...
}
}
DEBUG IT
The Plugin class

...
project.afterEvaluate {
}
}
}
DEBUG IT
The Plugin class
We add the task after the evaluation

THE TASK GRAPH
test
archive
test
hello

THE TASK GRAPH
test
archive
test
hello
Yay!

Very simple
As simple as Groovy is
Groovy is your best friend
A language very easy to mock
Junit & co
As anybody knows
TEST IT
Gradle
project
testing

ProjectBuilder
To create a mock project
Evaluate
To execute your mocked build script
A few
specificities
TEST IT

TEST IT
Adding a test class
Adding junit dependency

TEST IT
Our buid.gradle
...
repositories {
jcenter()
}
dependencies {
testCompile 'junit:junit:4.11'
}
...

TEST IT
Our buid.gradle
...
repositories {
jcenter()
}
dependencies {
}
...
Adding maven central repository

TEST IT
Our buid.gradle
...
repositories {
jcenter()
}
dependencies {
}
...
Adding junit as testing dependency

TEST IT
Your first test!
class ArchiveTestPluginTest {
@Test
public void canAddArchiveTestExtension() {
Project project = ProjectBuilder.builder().build()
project.apply plugin: 'java'
project.apply plugin: 'archivetest'
assert project.archivetest instanceof ArchiveTestPluginExtension
}
}

TEST IT
Your first test!
@Test
}
}
Mock a Gradle project

TEST IT
Your first test!
@Test
}
}
Apply Java plugin
To create ‘test’ task

TEST IT
Your first test!
@Test
}
}
Apply our plugin

TEST IT
Your first test!
@Test
}
}
Test our extension exists

TEST IT
Your second test!
@Test
public void canAddArchiveTask() {
assert project.tasks.archivetest instanceof ArchiveTask
}
}
We initialize our project

TEST IT
Your second test!
@Test
public void canAddArchiveTask() {
}
}
We test the task

TEST IT
Run your second test
$ gradle test --stacktrace --debug

TEST IT
...
test.groovy.fr.eyal.ArchiveTestPluginTest > canAddArchiveTask FAILED
MissingPropertyException: Could not find property 'archivetest' on task set
...
BUILD FAILED

TEST IT
...
test.groovy.fr.eyal.ArchiveTestPluginTest > canAddArchiveTask FAILED
MissingPropertyException: Could not find property 'archivetest' on task set
...
BUILD FAILED
Our task is not created

...
project.afterEvaluate {
//create the tasks
//inject the task
}
}
}
TEST IT
The Plugin class
Tasks are often created after project.
evaluate()

TEST IT
Your first test!
@Test
void canAddArchiveTask() {
project.evaluate()
}
} We launch evaluate() on the project

TEST IT
...
BUILD SUCCESSFUL

TEST IT
...
BUILD SUCCESSFUL
Yay!

TEST IT
LUKE DALEY
Gradleware Principal Engineer
GRADLE FORUM
You don't see this in the API docs for Project
because it is an internal method and is therefore
potentially subject to change in future releases.
There will be a supported mechanism for doing this
kind of thing in the near future.
”
“

TEST IT
LUKE DALEY
Gradleware Principal Engineer
GRADLE FORUM
You don't see this in the API docs for Project
because it is an internal method and is therefore
potentially subject to change in future releases.
There will be a supported mechanism for doing this
kind of thing in the near future.
June 2011
”
“

Plugin Base Java
vs. Plugin Java
Defines what is a test task
tasks.withType(Test)
IMPROVE IT
Convention
over
Configuration

Avoid running useless tasks
UP-TO-DATE
Declare Inputs
@Input, @InputFile, @InputFiles, @InputDirectory
Declare outputs
@OutputFile, @OutputDirectory
IMPROVE IT
Incremental
builds

More flexibility of annotations
@InputFile String filePath
@InputDirectory String directoryPath
...
IMPROVE IT
Coming
soon

OnlyIf
Conditional task execution
IMPROVE IT
Tweaking
Execution
Graph

ArchiveTask() {
onlyIf {
!parent.state.skipped
}
}
IMPROVE IT

Gradle Plugin documentation
https://gradle.org/documentation
References

SLIDES
http://bit.ly/gradle-plugin-devoxx
Thank you!

Gradle plugin, take control of the build

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Andere mochten auch

Andere mochten auch (6)

Ähnlich wie Gradle plugin, take control of the build

Ähnlich wie Gradle plugin, take control of the build (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Gradle plugin, take control of the build