The Workshop. Slides (you have a copy in the zip) Practical labs Ask questions

Transcription

1 Gradle Workshop

2 The Workshop Slides (you have a copy in the zip) Practical labs Ask questions

3 The Labs Pairing is encouraged Solutions are available (but avoid cheating) Take your time and experiment First lab is Gradle installation/setup.

4 Objectives Gradle introduction Cover fundamental concepts Go beyond using Gradle builds Look at some of the newer features

5 Agenda The Gradle Project Groovy and Gradle Basics Tasks Task Inputs/Outputs Plugins Java Plugin Feature Tour Dependency Management (time permitting)

6 Gradle Introduction

7 Gradle Gradle is a build tool with a focus on whole project automation and support for multi-language development. Created in 2008 Implemented in Java (Groovy outer layer) 100% Free Open Source - Apache Standard License 2.0

8 Gradleware The company behind Gradle. Employs full time engineers Gradle consulting, support, development services etc. Training: online, public and in-house General build automation services Germany, Australia, Austria, Switzerland, Sweden, Czech Republic, UK, Canada and the US.

9 Gradle Project Open Source (Apache v2 license), free to use and modify Source code at github.com/gradle/gradle Community centered around forums.gradle.org

10 Gradle Documentation User Guide 300+ pages, many complete samples In depth explanations, introductions single page HTML multi page HTML PDF DSL Reference ( gradle.org/docs/current/dsl/ ) API reference Frequently accessed Links through to Javadoc

11 Gradle Downloads -bin distribution contains just the runtime. -all distribution contains the runtime, source, and all documentation.

12 Gradle 2.2 Released on Nov 10th, 2014 Latest version

13 Lab 01-setup

14 Groovy and Gradle Basics

15 Groovy Modern scripting language for the JVM Design goal is to be easily picked up by Java developers Reuse of Java semantics and API Compiles to byte code

16 Groovy Language Features Dynamic and optional static typing Compile time and runtime metaprogramming Operator overloading (e.g, <<, +=, -= on collections) Removes a lot of Java syntax noise (no semicolons etc.) First-class properties Closures (cf. Ruby blocks, Javascript functions, Java 8 lambdas) Many JDK library enhancements

17 More Groovy Groovy has many uses outside Gradle. Particularly good for testing Java code. Groovy In Action (2nd Ed) is a great source for more Groovy goodness.

18 Groovy and Gradle Gradle is implemented in Java, with an outer Groovy layer. Gradle build scripts are written in a Groovy-based DSL. Gradle tasks and plugins can be written in Groovy. apply plugin: "java" description = "My first Gradle build" version = 1.0 repositories { mavencentral() dependencies { compile "org.springframework:spring-core:4.0.5.release" test { jvmargs "-Xmx1024m"

19 Gradle Build Scripts Named build.gradle by default Must be valid Groovy syntax Can t be executed by plain Groovy runtime Are backed by a org.gradle.api.project object // does not compile: println 'Gradle // compiles, fails when run with Groovy or Gradle: println zipcode // compiles, fails when run with plain Groovy: println name

20 Tasks

21 Tasks Tasks are the basic unit of work in Gradle. Declared & configured by build scripts and plugins Executed by Gradle task helloworld { dolast { println "Hello World!" task is a keyword in the Gradle DSL. All tasks implement the Task interface.

22 Task Actions Tasks have a list of actions. task helloworld { dolast { println "World!" dofirst { println "Hello" Executing a task means executing all of its actions (in order). Most tasks have one useful main action. dofirst() and dolast() can be used to further decorate this action.

23 Executing Tasks Execute tasks by specifying them on the command line. $ gradle helloworld :helloworld Hello world!

24 Abbreviated Task Name Execution Task names can be abbreviated on the command line. task mynameisprettylong { dolast { println "Long name" task someothertask { dolast { println "Other task" //running: $ gradle mnipl sothert Characters between word boundaries can be dropped.

25 Task Dependencies A task may require other tasks to run (i.e. produce or do something) before it can run Tasks and their dependencies form a directed acyclic graph (DAG) task compilejava task processresources task jar { dependson compilejava dependson processresources

26 Task Types Most tasks explicitly specify a type. task copyfiles(type: Copy) { // configure the task Task types (e.g. The default task type is Copy) provide a task action and a configuration API. DefaultTask, and does not have an action.

27 Task API task helloworld { onlyif { System.getProperty("be.nice") == "true" dolast { println "Hello" The onlyif() and dolast() methods are available for all tasks (i.e. are part of the Task interface). task copyfiles(type: Copy) { from "sourcedir" into "targetdir" The from() and into() methods are only available for Copy tasks. The task's API allows the task to be configured.

28 Implementing Task Types POJO extending DefaultTask Declare action class FtpTask extends DefaultTask { String host = void ftp() { // do something complicated

29 Lab 02-custom-tasks

30 Build Lifecycle Initialization Phase Configure environment (init.gradle, gradle.properties) Find projects and build scripts (settings.gradle) Configuration Phase Evaluate all build scripts Build object model (Gradle -> Project -> Task, etc.) Build task execution graph Execution Phase Execute (subset of) tasks A key concept to grasp.

31 Lab 03-build-lifecycle

32 Quick Quiz Bonus question: What's happening here? task bar { dolast { dependson foo Will foo execute before bar?

33 Task Modeling tasks as functions Inputs/Outputs

34 Inputs and Outputs Most tasks can be described as functions Inputs : Files, configuration values Outputs: Files Modeling inputs and outputs enables powerful features: Do not rerun tasks that would produce the same outputs. Infer task dependency if one task's output becomes another task's input. Validate that task inputs exist before running a task. Create output directories that don't exist. Clean all outputs of a particular task. Etc. Built-in task types already describe their inputs and outputs. When implementing a custom task type, tell Gradle what its inputs and outputs are.

35 Input/Output Annotations class MyTask extends DefaultTask File FileCollection File String File transformedtemplates boolean verbose // generate() {...

36 Incremental Building A task can be skipped (UP-TO-DATE) if: Inputs have not changed since last run Outputs are still there and haven't changed Change detection is content (not time) based: Input/output files are hashed Content of input/output dirs is hashed Values of input properties are serialized

37 Dependency Inference Many Gradle types (e.g. FileCollection and ProjectDependency) implement Buildable. Any task input that is Buildable creates inferred task dependencies. task generatefiles { outputs.dir = "$builddir/generated-files" // same dolast { /* generate files */ compilejava { classpath += generatefiles.outputs.files // -> generatefiles task copy(type: Copy) { from generatefiles // -> generatefiles into "somedir" jar { from sourcesets.main.output // -> compilejava, processresources from sourcesets.test.output // -> compiletestjava, processtestresources

38 Lab 04-task-input-output

39 Plugins

40 Plugins Plugins are reusable build logic. They can do everything a build script can do (and vice versa): Configure defaults Add and configure tasks Extend the build language Etc. Script plugins are applied by path: apply from: "$rootdir/gradle/integration-test.gradle" Binary plugins are applied by ID: apply plugin: "java"

41 External Plugins Need to be declared as build script dependencies. buildscript { repositories { mavencentral() dependencies { classpath "org.hidetake:gradle-ssh-plugin:0.3.7" apply plugin: "ssh"

42 Standard Gradle Plugins Gradle ships with many useful plugins. Some examples: java - compile, test, package, upload Java projects checkstyle - static analysis for Java code maven - uploading artifacts to Apache Maven repositories scala - compile, test, package, upload Scala projects idea and eclipse - generates metadata so IDEs understand the project application - support packaging your Java code as a runnable application c / cpp - support building native binaries using gcc, clang or visual-cpp Many more, listed in the Gradle User Guide.

43 The Java Plugin

44 Java Plugin The basis of Java development with Gradle. Introduces concept of source sets main and test source set conventions Compilation pre-configured Dependency management JUnit & TestNG testing Produces single JAR JavaDoc generation Publishing (Maven or Ivy format) IDE integration Standard lifecycle/interface

45 Source Sets A logical compilation/processing unit of sources. Java source files Non compiled source files (e.g. properties files) Classpath (compile & runtime) Output class files Compilation tasks sourcesets { main { java { srcdir "src/main/java" // default resources { srcdir "src/main/resources" // default

46 Lifecycle Tasks The java plugin provides a set of lifecycle tasks for common tasks. clean - delete all build output classes - compile code, process resources test - run tests assemble - make all archives (e.g. zips, jars, wars etc.) check - run all quality checks (e.g. tests + static code analysis) build - combination of assemble & check

47 Testing Built in support for JUnit and TestNG. Pre-configured test task Automatic test detection Forked JVM execution Parallel execution Configurable console output Human and CI server friendly reports

48 Lab 05-java-plugin

49 Feature Tour A small selection of useful features.

50 Gradle Wrapper A way to bootstrap Gradle installations. $ gradle wrapper gradle gradle-wrapper.jar gradle-wrapper.properties gradlew gradlew.bat $./gradlew build

51 Build Daemon Makes builds start faster. Enable with --daemon command line option org.gradle.daemon=true in gradle.properties -Dorg.gradle.daemon=true in GRADLE_OPTS Force shutdown with gradle --stop Will be used in the future for more optimization.

52 Init Plugin Create build from template, convert Maven build. $ gradle init --type java-library $ gradle init --type pom

53 Continue after Failure $ gradle build --continue Especially useful for CI builds.

54 Parallel Builds Run independent tasks from different projects in parallel. $ gradle build --parallel Incubating feature; some restrictions apply.

55 Q&A Thank you for attending the workshop Questions? Feedback?

56 Dependency Management

57 Dependency Management Gradle supports managed and unmanaged dependencies. Managed dependencies have identity and possibly metadata. Unmanaged dependencies are just anonymous files. Managed dependencies are superior as their use can be automated and reported on.

58 Unmanaged Dependencies dependencies { compile filetree(dir: "lib", include: "*.jar") Can be useful during migration.

59 Managed Dependencies dependencies { compile "org.springframework:spring-core:4.0.5.release" compile group: "org.springframework", name: "spring-web", version: "4.0.5.RELEASE" Group/Module/Version

60 Configurations Dependencies are assigned to configurations. configurations { // default with `java` plugin compile runtime testcompile testruntime dependencies { compile "org.springframework:spring-core:4.0.5.release" See Configuration in DSL reference.

61 Transitive Dependencies Gradle (by default) fetches dependencies of your dependencies. This can introduce version conflicts. Only one version of a given dependency can be part of a configuration. Options: Use default strategy (highest version number) Disable transitive dependency management Excludes Force a version Fail on version conflict Dependency resolution rules

62 Disable Transitives Per dependency dependencies { compile("org.foo:bar:1.0") { transitive = false Configuration-wide configurations { compile.transitive = false

63 Excludes Per dependency dependencies { compile "org.foo:bar:1.0", { exclude module: "spring-core" Configuration-wide configurations { compile { exclude module: "spring-core"

64 Version Forcing Per dependency dependencies { compile("org.springframework:spring-core:4.0.5.release") { force = true Configuration-wide configurations { compile { resolutionstrategy.force "org.springframework:spring-core:4.0.5.release"

65 Fail on Conflict Automatic conflict resolution can be disabled. configurations { compile { resolutionstrategy.failonversionconflict() If disabled, conflicts have to be resolved manually (using force, exclude etc.)

66 Cross Configuration Rules Configuration level rules can be applied to all configurations. configurations { all { resolutionstrategy.failonversionconflict() all is a special keyword, meaning all things in the configuration container.

67 Dependency Cache Default location: ~/.gradle/caches/. Multi process safe Source location aware Optimized for reading (finding deps is fast) Checksum based storage Avoids unnecessary downloading Finds local candidates Uses checksums/etags An opaque cache, not a repository.

68 Changing Dependencies Changing dependencies are mutable. Version numbers ending in -SNAPSHOT are changing by default. dependencies { compile "org.company:some-lib:1.0-snapshot" compile("org:somename:1.0") { changing = true Default TTL is 24 hours.

69 Dynamic Dependencies Dynamic dependencies do not refer to concrete versions. Can use Ivy symbolic versions. dependencies { compile "org.company:some-lib:2.+" compile "org:somename:latest.release" Default TTL is 24 hours.

70 Controlling Updates & TTL configurations.all { resolutionstrategy.cachechangingmodulesfor 4, "hours" resolutionstrategy.cachedynamicversionsfor 10, "minutes" --offline - don't look for updates, regardless of TTL --refresh-dependencies - look for updates, regardless of TTL

71 Dependency Reports View the dependency graph. $ gradle dependencies [--configuration «name»] View a dependency in the graph. $ gradle dependencyinsight --dependency «name» [--configuration «name»] Built in tasks.

72 Repositories Any Maven/Ivy repository can be used Very flexible layouts are possible for Ivy repositories repositories { jcenter() mavencentral() maven { name "codehaus" url " ivy { url " layout "gradle" // default flatdir(dirs: ["dir1", "dir2"])

73 Lab 06-dependencies

74 Uploading Upload your artifacts to any Maven/Ivy repository ivy.xml/pom.xml is generated Repository metadata (e.g. maven-metadata.xml) is generated

75 Uploading to Maven Repositories apply plugin: "maven" uploadarchives { repositories { mavendeployer { repository(url: " Provided by the maven plugin All Maven wagon protocols can be used For Artifactory, JFrog provides an artifactory-publish plugin