node(jenkinsEnv.nodeSelection(osNode)) {
    dir('build') {
        stage('Checkout') {
            checkout scm
        }

        def WORK_DIR=pwd()
        def MAVEN_GOAL='verify'

        stage('Configure deploy') {
           if (env.BRANCH_NAME in ['master', 'maven-3.8.x', 'maven-3.9.x']){
               MAVEN_GOAL='deploy'
           }
        }

        stage('Build / Unit Test') {

or follow the "Explore performance" link on the build scan home page:

image::performance/build-scan-home.png[title="Performance page link on build scan home page"]

The performance page shows how long it took to complete different stages of a build.
This page shows how long it took to:

- start up
- configure the build's projects
- resolve dependencies
- execute tasks

import jetbrains.buildServer.configs.kotlin.buildSteps.GradleBuildStep
import model.CIBuildModel
import model.JsonBasedGradleSubprojectProvider
import model.PerformanceTestCoverage
import model.PerformanceTestType
import model.Stage
import model.StageName
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Test
import java.io.File

class PerformanceTestBuildTypeTest {
    init {
        DslContext.initForTest()

The build state is managed by the `BuildState` class.
An instance is created for each build in the build definition, once per build execution and is discarded at the end of the execution. 

The build state also includes what is currently called the "Gradle state". The Gradle state is being merged into the build state and is mostly empty.

### Project state

          days-before-issue-stale: 14
          stale-issue-label: to-triage
          stale-issue-message: ""
          days-before-issue-close: -1

          only-pr-labels: 'from:contributor'
          exempt-all-pr-milestones: true
          days-before-pr-stale: 14
          stale-pr-label: to-triage
          stale-pr-message: ""

        echo "OS: ${os} JDK: ${jdk} => Label: ${osLabel} JDK: ${jdkName} Arch: s390x"

        String stageId = "${os}-jdk${jdk}-s390x"
        String stageLabel = "Run ITs ${os.capitalize()} Java ${jdk} on s390x"
        runITsTasks[stageId] = {
            node('s390x') {
                stage("${stageLabel}") {
                    echo "NODE_NAME = ${env.NODE_NAME}"

**/*.swp
cover.out
*~
minio
!*/
site/
**/*.test
**/*.sublime-workspace
/.idea/
/Minio.iml
**/access.log
vendor/
.DS_Store
*.syso
coverage.txt
.vscode/
*.tar.bz2
parts/
prime/
stage/
.sia_temp/
config.json
node_modules/
mc.*
s3-check-md5*
xl-meta*
healing-*
inspect*.zip
200M*
hash-set
minio.RELEASE*
mc
nancy
inspects/*
.bin/
*.gz

        GradleVersion versionObject = GradleVersion.version(version)
        // there is no public API for checking for RC version, this is an internal way
        return versionObject.snapshot || versionObject.stage?.stage == 3
    }

    private static GradleDistribution findRelease(ReleasedVersionDistributions releases, String requested) {
        GradleDistribution best = null
        for (GradleDistribution release : releases.all) {

import org.gradle.internal.remote.ObjectConnection;
import org.gradle.process.internal.worker.WorkerProcessContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * <p>The final stage of worker start-up. Takes care of executing the worker action.</p>
 *
 * <p>It is instantiated and called from {@link SystemApplicationClassLoaderWorker}.<p>
 */

You can learn more about advanced Travis CI usage through these resources:

* https://docs.travis-ci.com/user/encryption-keys/[Encrypting sensitive data]
* https://docs.travis-ci.com/user/build-stages/[Modelling a pipeline with build stages]

== Summary

Executing Gradle builds on CI can be set up and configured with just a handful of steps.
The benefit of receiving fast feedback clearly speaks for itself.