MvnBuild

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

Note

If your maven project is already using the Maven Artifactory plugin, see Setting Up Maven Builds for Pipelines for information about configuring your Maven settings for use in JFrog Pipelines.Ecosystem Integration

Using this step automatically selects Java as the language and bootstraps the runtime environment in the node appropriately.

Important

The MvnBuild native step uses Java runtime image by default. If runtime image of any other type is configured at pipeline-level for this native step, it will be ignored.

YAML Schema

MvnBuild

pipelines: 
  - name:   <string>
    steps:
      - name: <string>
        type: MvnBuild
        configuration:
          #inherits all the tags from bash
          mvnCommand:           <string>      # optional
          sourceLocation:       <string>      # optional
          resolverSnapshotRepo: <string>      # optional
          resolverReleaseRepo:  <string>      # optional
          deployerSnapshotRepo: <string>      # optional
          deployerReleaseRepo:  <string>      # optional
          forceXrayScan:        <string>      # optional
          failOnScan:           <boolean>     # default true
          autoPublishBuildInfo: <string>      # optional
          configFileLocation:   <string>      # optional
          configFileName:       <string>      # optional

          integrations:
            - name:         <Artifactory integration>  # required
          inputResources:
            - name:         <GitRepo resource>         # required
            - name:         <FileSpec resource>        # optional
          outputResources:
            - name:         <BuildInfo resource>       # if autoPublishBuildInfo is true

        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"

Tag	Description of usage	Required/Optional
`integrations`	Must specify an Artifactory Integration	Required
`inputResources`	Must specify a GitReporesource. The mvn command performs 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 will be used for the output BuildInfo. Otherwise, the default `buildName` and `buildNumber` are `$pipeline_name` and `$run_number.`	May be required

Note

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
`mvnCommand`	Specifies a command line string of options to use with Maven. Default is `clean install`.	Optional
`sourceLocation`	Specifies the location of the source files. By default this is set to the root directory of the GitRepo resource. Defaults to the root of the GitRepo. Required if the source files are not in the root directory.	May be required
`resolverSnapshotRepo`	Artifactory repository to resolve snapshot dependencies. If set, `resolverReleaseRepo` is also required. Note Do not use with `configFileName` and `configFileLocation`.	Optional
`resolverReleaseRepo`	Artifactory repository to resolve release dependencies. If set, `resolverSnapshotRepo` is also required. Note Do not use with `configFileName` and `configFileLocation`.	Optional
`deployerSnapshotRepo`	Snapshot artifacts created by the MvnBuild are uploaded to this Artifactory repository. If set, `deployerReleaseRepo` is also required. Note Do not use with `configFileName` and `configFileLocation`.	Optional
`deployerReleaseRepo`	Release artifacts created by the MvnBuild are uploaded to this Artifactory repository. If set, deployerSnapshot`Repo` is also required. Note Do not use with `configFileName` and `configFileLocation`.	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`.Creating Xray Policies and Rules	Optional
`autoPublishBuildInfo`	When set to `true`, publishes build info to Artifactory. Requires a BuildInfo resources in the outputResources list. Default is `false`.	Optional
`configFileName`	Specifies the name of the JFrog CLI mvn-config file. The `serverID` in the configuration file should match the Artifactory integration name. If set, `configFileLocation`is also required. Note This option should be used only if you have committed this configuration file to your source	Optional
`configFileLocation`	Specifies the directory containing the JFrog CLI mvn-config file, relative to the `sourceLocation` . If set, `configFileName` is also required. Note This option should be used only if you have committed this configuration file to your source	Optional

execution

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

Tag	Description of usage	Required/Optional
`onStart`	Commands to execute in advance of the native operation	Optional
`onSuccess`	Commands to execute on successful completion	Optional
`onFailure`	Commands to execute on failed completion	Optional
`onComplete`	Commands to execute on any completion	Optional

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 MvnBuild step can be configured.

Full Pipeline Example

This example requires an Artifactory Integration and a GitHub Integration.GitHub Integration
The Pipelines DSL for this example is available in this repository in the JFrog GitHub account.
For a full tutorial, see Pipeline Example: Maven Build.

# This config file is templatized so that it can be easily customized. Values can be provided with a values.yml file.
template: true   # required for local templates
valuesFilePath: ./values.yml

resources:
  - name: mvn_repo
    type: GitRepo
    configuration:
      path: {{ .Values.repoPath }}
      gitProvider: {{ .Values.gitProvider }}

  - name: mvn_build_info
    type: BuildInfo
    configuration:
      sourceArtifactory: {{ .Values.artifactory }}

pipelines:
  - name: demo_maven
    steps:
      - name: mvn_build_step
        type: MvnBuild
        configuration:
          deployerSnapshotRepo: {{ .Values.deployerRepo }}
          deployerReleaseRepo: {{ .Values.deployerRepo }}
          inputResources:
            - name: mvn_repo
          integrations:
            - name: {{ .Values.artifactory }}

      - name: publish_build
        type: PublishBuildInfo
        configuration:
          forceXrayScan: false
          inputSteps:
            - name: mvn_build_step
          outputResources:
            - name: mvn_build_info

Basic Example using Default Values

The most basic form of MvnBuild. Uses all default values. This step navigates to the root of the repo specified in the inputResources array, and performs an mvn clean install. It does not publish a build or request an Xray scan.

MvnBuild

pipelines: 
  - name: MyMavenPipeline
    steps:
      - name: MavenWithArtifactory
        type: MvnBuild
        configuration:
          integrations:
            - name: art
          inputResources:
            - name: mvn_repo

Using Artifactory as Resolver and Deployer

This example uses Artifactory as a resolver and a deployer, so that your project's dependencies are pulled from the specified repo, and the resulting artifacts are pushed back up to Artifactory. It also publishes build info to Artifactory and requests an Xray scan.

MvnBuild

pipelines: 
  - name: MyMavenPipeline
    steps:
      - name: MavenWithAll
        type: MvnBuild
        configuration:
          integrations:
            - name: art
          inputResources:
            - name: mvn_repo
          outputResources:
            - name: mvn_build_info
          mvnCommand: clean install test
          sourceLocation: mvnproject
          resolverSnapshotRepo: snapshots-remote-maven
          resolverReleaseRepo: releases-remote-maven
          deployerSnapshotRepo: snapshots-local-maven
          deployerReleaseRepo: releases-local-maven
          forceXrayScan: true
          failOnScan: true
          autoPublishBuildInfo: true

Using a Config File

This example uses a committed config file to accomplish the same thing that example 2 does.

MvnBuild

pipelines: 
  - name: MyMavenPipeline
    steps:
      - name: MvnWithConfig
        type: MvnBuild
        configuration:
          integrations:
            - name: art
          inputResources:
            - name: mvn_repo
          outputResources:
            - name: mvn_build_info
          mvnCommand: clean install test
          sourceLocation: mvnproject
          configFileLocation: "."
          configFileName: mvn-art-config
          forceXrayScan: true
          failOnScan: true
          autoPublishBuildInfo: true

How it Works

When you use the MvnBuild native step in a pipeline, it performs the following actions in the background:

MvnBuildCommands

jfrog rt config                        # configures JFrog CLI with the integration listed in the yaml
jfrog rt mvn-config             # if configFileName and configFileLocation are not set in yaml
jfrog rt mvn $mvnCommand        # the main maven build command
add_run_variables                       # saves some information in run state for future steps to reference
jfrog rt build-collect-env      # collects build environment, preparing for build publish
jfrog rt build-publish          # only if autoPublishBuildInfo is true
write_output                            # updates the buildinfo resource, if present
jfrog rt build-scan             # if forceXrayScan is true
add_run_files                           # adds BuildInfo to run state

MvnBuild

JFrog Pipelines Documentation

Note

Important

YAML Schema

Tags

name

type

configuration

Note

Note

Note

Note

Note

Note

Note

execution

Examples

Full Pipeline Example

Basic Example using Default Values

Using Artifactory as Resolver and Deployer

Using a Config File

How it Works