Cloud customer?
Start for Free >
Upgrade in MyJFrog >
What's New in Cloud >

Search





Overview

The GradleBuild native step performs a Gradle build on files in a Git repository. Optionally, it can also publish build information to Artifactory.


This step utilizes the JFrog CLI to run a Gradle build for your project. The CLI config file can be created during execution, or you can generate it ahead of time with the settings you require and commit it to your repository. For information about gradle-config, see CLI for JFrog Artifactory.

Page Contents


YAML Schema

The YAML schema for GradleBuild native step is as follows:

GradleBuild
pipelines: 
  - name:   <string>
    steps:
      - name: <string>
        type: GradleBuild
        configuration:
		  #inherits all the tags from bash; https://www.jfrog.com/confluence/display/JFROG/Bash

          gradleCommand: 		<string>	#required
          sourceLocation:   	<string>	#optional
          configFileLocation:   <string>	#optional
		  configFileName:		<string>	#optional
          resolverRepo:         <string>	#optional
		  deployerRepo:		    <string>	#optional
		  usesPlugin:           <string>	#optional
		  useWrapper:		    <string>	#optional
		  forceXrayScan:		<boolean>	#optional
          failOnScan:           <boolean>   #optional; default true
		  autoPublishBuildInfo:	<boolean>	#optional
          inputResources:
   			- name: myGitRepo	
			- name: artifactoryFileSpec	
		  outputResources:
			- name: myBuildInfo
      	  integrations:
			- name: myArtifactory 
        execution:
          onStart:
            - echo "Preparing for work..."
          onSuccess:
            - echo "Job well done!"
          onFailure:
            - echo "uh oh, something went wrong"
          onComplete: #always
            - echo "Cleaning up some stuff"

Tags

name 

An alphanumeric string (underscores are permitted) that identifies the step.

type 

Must be GradleBuild for this step type.

configuration

Specifies all configuration selections for the step's execution environment. This step inherits the Bash/PowerShell step configuration tags, including these pertinent tags:

Tag

Description of usage

Required/Optional

integrationsMust specify an Artifactory Integration.Required
inputResources 

Must specify GitRepo resourceThe Gradle command will perform the build on files in the Git repository at sourceLocation.

May also optionally specify a FileSpec resource that specifies what files to copy to sourceLocation to build.

Required
outputResources 

Must specify a BuildInfo resource if autoPublishBuildInfo is set to true

If JFROG_CLI_BUILD_NAME or JFROG_CLI_BUILD_NUMBER is set as an environment variable for the pipeline or the step, that name and/or number is used for the output BuildInfo. Otherwise, the default buildName and buildNumber are $pipeline_name and $run_number.

May be required


In addition, these tags can be defined to support the step's native operation:

Tags derived from Bash

All native steps derive from the Bash step. This means that all steps share the same base set of tags from Bash, while native steps have their own additional tags as well that support the step's particular function. So it's important to be familiar with the Bash step definition, since it's the core of the definition of all other steps.

Tag

Description of usage

Required/Optional
gradleCommandSpecifies a command line string of options to use with the Gradle build tool.Required
sourceLocationLocation of the source files to build relative to the root of the GitRepo repository. If no path is specified, the root of the repository will be used.Optional
resolverRepoArtifactory repository to be used to resolve dependencies. May not be used with configFileName and configFileLocation.Optional
deployerRepoArtifactory repository to which to deploy. May not be used with configFileName and configFileLocation.Optional
usesPlugin

Set to true if the Gradle Artifactory Plugin is already applied in the build script. Default is false

Do not use with configFileName and configFileLocation (you can enable this option directly in your existing config file).

Optional
useWrapper

If set to true, use the Gradle wrapper. Default is false

Do not use with configFileName and configFileLocation (you can enable this option directly in your existing config file).

Optional
forceXrayScan

When set to true, forces an Xray scan after publishing to Artifactory.

Default is false.

Optional
failOnScan

When set to true, and when the Xray Policy Rule Fail Build checkbox is checked, a failed Xray scan will result in a failure of the step.

Default is true.

Optional
autoPublishBuildInfo

When set to true, publishes build info to Artifactory.

Default is false.

Optional
configFileName

Gradle configuration file. If specified, the configFileLocation tag is also required. This file is generated using the JFrog CLI when you run jfrog rt gradle-config command.

The serverID in the configuration file should match the Artifactory integration name.

Use this option only if you have committed this configuration file to your source.

Optional
configFileLocationGradle configuration file location. A configFileName tag is also required. Typically stored in the .jfrog directory in the repository.Optional


execution

Declares collections of shell command sequences to perform for pre- and post-execution phases:

TagDescription of usageRequired/Optional
onStartCommands to execute in advance of the native operationOptional
onSuccessCommands to execute on successful completionOptional
onFailureCommands to execute on failed completionOptional
onCompleteCommands to execute on any completionOptional


The actions performed for the onExecute phase are inherent to this step type and may not be overridden.


Examples

The following examples show a few ways in which a GradleBuild step can be configured.

Using Default Values

The most basic form of GradleBuild. Uses all default values. This step will navigate to the root of the repo specified in the inputResources array, and run the specified Gradle command.

GradleBuild
pipelines: 
  - name: gradleBuildPipeline
    steps:
      - name: gradleBuildStep
        type: GradleBuild
        configuration: 
          gradleCommand: "build"
          inputResources:
            - name: gitRepoResource
          integrations:
            - name: artifactory_integration

Source Location is a Sub-directory of Git Repo

A more complicated GradleBuild step, in this one the source location is a subdirectory of the GitRepo (gradle-example-minimal) and the project uses the  Gradle Artifactory Plugin. Resolver and deployer repositories have also been configured, resolving from jcenter and deploying to gradle-local.

GradleBuild
pipelines: 
  - name: gradleBuildPipeline
    steps:
      - name: gradleBuildStep
        type: GradleBuild
        configuration: 
          gradleCommand: "artifactoryPublish clean -b build.gradle"
          sourceLocation: gradle-example-minimal
          deployerRepo: gradle-local
          resolverRepo: jcenter
          usesPlugin: true
          inputResources:
            - name: gitRepoResource
          integrations:
            - name: artifactory_integration

Using Config File

This GradleBuild step is similar to the previous example, but has a config file committed to the repository as gradle-example-minimal/gradle-art-config. The config file contains the repository and plugin settings.

GradleBuild
pipelines: 
  - name: gradleBuildPipeline
    steps:
      - name: gradleBuildStep
        type: GradleBuild
        configuration: 
          gradleCommand: "artifactoryPublish clean -b build.gradle"
          sourceLocation: gradle-example-minimal
          configFileLocation: .
          configFileName: gradle-art-config
          inputResources:
            - name: gitRepoResource
          integrations:
            - name: artifactory_integration

Publish Build Info and Trigger Xray Scan

In this example, build info is published as part of the GradleBuild step and an Xray scan is triggered.

GradleBuild
pipelines: 
  - name: gradleBuildPipeline
    steps:
      - name: gradleBuildStep
        type: GradleBuild
        configuration: 
          gradleCommand: "build"
          autoPublishBuildInfo:	true
          forceXrayScan: true
          inputResources:
            - name: gitRepoResource
          integrations:
            - name: artifactory_integration
          outputResources:
			- name: myBuildInfo

How it Works

When you use the GoPublishModule native step in a pipeline, it performs the following functions in the background:

  • jfrog rt config (configure JFrog CLI with the integration listed in the yaml)
  • jfrog rt gradle-config (if configFileName and configFileLocation are not set in yaml )
  • jfrog rt gradle $gradleCommand (the main gradle build command)
  • add_run_variables (save information in run state for future steps to reference)
  • jfrog rt build-collect-env (collect the build environment, preparing for build publish)
  • jfrog rt build-publish (publish the build, only if autoPublishBuildInfo is true)
  • write_output (update the BuildInfo output resource with the published name/number)
  • jfrog rt build-scan (if forceXrayScan is true)
  • add_run_files (adds build info to run state)
  • No labels
Copyright © 2021 JFrog Ltd.