Configure Your CI Pipeline to record and publish build-info to JFrog Artifactory

To set up your CI to expose the information to IDEA, you need to include the following as part of your pipeline script.

Download JFrog CLI, so that it can be used in the pipeline:
```
curl -fL https://getcli.jfrog.io | sh && chmod +x jfrog
```

Set the following environment variables with the build name and build run number.

export JFROG_CLI_BUILD_NAME=<the build name>
export JFROG_CLI_BUILD_NUMBER=<the build run number>

Set the following environment variable, with the URL to the pipeline log on the CI.
```
export JFROG_CLI_BUILD_URL=<url to the pipeline log>
```
If needed, configure JFrog CLI using the following command.
```
./jfrog c add
```
If needed, configure the repositories for your project. For example, if your code is built using maven, run:
```
./jfrog rt mvnc
```
Run the command that builds your code using JFrog CLI. For example, if your code is built using maven, run:
```
./jfrog rt mvn clean install
```
Set the following environment variable, to indicate that the build finished successfully.
```
export JFROG_BUILD_STATUS=PASS
```
Make sure to set the environment variable's value to FAIL, to indicate a failure of the CI pipeline.
Record the environment variables and the project's git information as part of the build-info and then, publish the build-info to Artifactory. Make sure your pipeline always executes these commands, even in the case of a failure.
```
./jfrog rt bce
./jfrog rt bag
./jfrog rt bp
```
Optionally scan the published build with JFrog Xray by running
```
./jfrog rt bs
```

JFrog Pipelines Example

resources:
- name: mvn_example_pipelines_gitResource
  type: GitRepo
  configuration:
    path: jfrog/project-examples
    gitProvider: github_mvn_example_pipelines_integration
    buildOn:
      pullRequestCreate: true
    branches:
      include: main
- name: mvn_example_pipelines_pipeline_bi
  type: BuildInfo
  configuration:
    sourceArtifactory:    rt_mvn_example_pipelines_integration
pipelines:
  - name: mvn_example_pipelines_pipeline
    steps:
      - name: MvnBuild
        type: MvnBuild
        configuration:
          environmentVariables:
            'JFROG_CLI_BUILD_URL': $step_url
            'JFROG_BUILD_STATUS': 'PASS'
          mvnCommand:           clean install
          sourceLocation:       maven-example    
          resolverSnapshotRepo: maven-virtual
          resolverReleaseRepo:  maven-virtual
          autoPublishBuildInfo: true
          forceXrayScan:        true
          integrations:
            - name:         rt_mvn_example_pipelines_integration
          inputResources:
            - name:         mvn_example_pipelines_gitResource
          outputResources:
            - name:         mvn_example_pipelines_pipeline_bi
        execution:
          onFailure:
            - export JFROG_BUILD_STATUS=FAIL
            - jfrog rt bce
            - jfrog rt bp

Jenkins Example

pipeline {
  agent any
  environment {
    JFROG_CLI_BUILD_NAME = "${JOB_NAME}"
    JFROG_CLI_BUILD_NUMBER = "${BUILD_NUMBER}"
    JFROG_CLI_BUILD_URL = "https://<my-jenkins-domain>/<my-job-uri>/${BUILD_NUMBER}/console"
  }
  stages {
      stage ('Clone') {
          steps {
              git branch: 'master', url: "https://github.com/jfrog/project-examples.git"
          }
      }

      stage ('Config') {
          steps {
              sh 'curl -fL https://getcli.jfrog.io | sh && chmod +x jfrog'
              sh "./jfrog c add rt-server --url https://ecosysjfrog.jfrog.io --user ${RT_USERNAME} --password ${RT_PASSWORD}"
              sh './jfrog rt mvnc --server-id-deploy rt-server --server-id-resolve rt-server --repo-resolve-releases releases --repo-resolve-snapshots snapshots --repo-deploy-releases releases-local --repo-deploy-snapshots snapshots-local' 
          }
      }

      stage ('Exec Maven') {
          steps {
              dir('maven-example') {
                  sh '../jfrog rt mvn clean install'
              }
          }
      }
  }
    
  post {
      success {
          script {
              env.JFROG_BUILD_STATUS="PASS"
          }
      }
      
      failure {
          script {
              env.JFROG_BUILD_STATUS="FAIL"
          }
      }
      
      cleanup {
          sh './jfrog rt bce'
          sh './jfrog rt bag'
          sh './jfrog rt bp'
      }
  }
}

GitHub Actions Example

This example uses the setup-jfrog-cli GitHub Action, which already sets the JFROG_CLI_BUILD_NAME, JFROG_CLI_BUILD_NUMBER and JFROG_CLI_BUILD_URL behind the scenes.

name: 'JFrog CI Integration'
on: [push]
jobs:
 jfrog-ci-integration:
   runs-on: ubuntu-latest
   env:
     JF_ARTIFACTORY_1: ${{ secrets.JF_ARTIFACTORY_SECRET_1 }}
     JFROG_BUILD_STATUS: PASS
   steps:
     - name: Checkout
       uses: actions/checkout@v2
     - name: Setup JFrog CLI
       uses: jfrog/setup-jfrog-cli@v1
     - name: Set up JDK 11
       uses: actions/setup-java@v2
       with:
         java-version: '11'
         distribution: 'adopt'
     - name: Run Maven build
       run: |
         # Init JFrog CLI Maven config
         MVN_PATH=`which mvn` && export M2_HOME=`readlink -f $MVN_PATH | xargs dirname | xargs dirname`
         # Replace ‘my_art_server’ with your imported server
         jfrog rt mvn-config --server-id-resolve=my_art_server --repo-resolve-releases=libs-release-remote --repo-resolve-snapshots=libs-snapshot-remote
         # Build the maven project
         jfrog rt mvn clean install
     - name: Failure check
       run: |
         echo "JFROG_BUILD_STATUS=FAIL" >> $GITHUB_ENV
       if: failure()
     - name: Publish Maven build
       run: |
         # Collect environment variables for the build
         jfrog rt bce
         # Collect VCS details from git and add them to the build
         jfrog rt bag
         # Publish build info
         jfrog rt bp
         # Scan build
         jfrog rt bs
       if: always()