Cloud customer?
 Upgrade in MyJFrog >

Search





Overview

A GitRepo is used to connect JFrog Pipelines to a source control repository. Adding it creates a webhook to the repo so that future commits will automatically create a new version with the webhook payload.


The first version of the resource, used if it is an input to a step that runs before any webhooks are received, will be for the latest commit in the default branch on the source provider at the time the resource is created. Later resource versions can be restricted by the branches, tags, and buildOn options.

A developer can suppress triggering for an individual commit by including [skipRun] in the commit message.

The GitRepo resource provides Pipelines with read-only access to the source repository through the created deploy key. It is not possible to write to the source repository from Pipelines.

Once a GitRepo resource has been created, the path attribute cannot be changed, since Pipelines maintains a history of versions for that path.

If the path needs to be changed, you must create a new GitRepo resource with the new path. You must then update your pipelines to reference that new GitRepo resource. 

Page Contents

Usage

resources:
  - name: 		<string>
    type: 		GitRepo
    configuration:
      gitProvider: 	<git integration name>
      path: 		<string>
      files:
        include: 	<regular expression>
        exclude: 	<regular expression>
      branches:
        include: 	<regular expression>
        exclude: 	<regular expression>
      tags:
        include: 	<regular expression>
        exclude: 	<regular expression>
      buildOn:
         commit: 			<Boolean>
         pullRequestCreate: <Boolean>
         pullRequestClose: 	<Boolean>
         releaseCreate:		<Boolean>
         tagCreate:			<Boolean>
      cancelPendingRunsOn:
         newCommit:         <Boolean>
         pullRequestUpdate: <Boolean>
      shallowDepth: 	<Positive Integer> 	# used to set the depth at which the repo is (shallow)cloned/fetched
   

Tags

name 

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

type 

Must be GitRepo for this resource type.

configuration

Specifies all configuration selections for the resource.


Tag

Description

Required/Optional

gitProvider 

The name of the source control integration. Currently supported integration types are:Required
path The path of the repository from the integration rootRequired
files
  • include -- (optional) Regular expression to include files meeting the pattern from the repo
  • exclude -- (optional) Regular expression to include files meeting the pattern from the repo
Optional
branches
  • include -- (optional) Regular expression to include branches from the repo
  • exclude -- (optional) Regular expression to exclude branches from the repo 
Optional
tags 

Used to specify a collection of tags and releases upon which a new version is created

  • include -- (optional) Regular expression to include tags meeting the pattern from the repo
  • exclude -- (optional) Regular expression to exclude tags meeting the pattern from the repo
Optional
buildOn 

Used to control whether the resource will be updated on specified events

  • commit-- (default is true) used to control whether the resource will be updated for commit webhooks
  • pullRequestCreate -- (default is false) used to control whether the resource will be updated for pull request webhooks
  • pullRequestClose -- (default is false) used to control whether the resource will be updated for closing a pull request webhook
  • releaseRequestCreate -- (default is false) used to control whether the resource will be updated for release webhooks
  • tagCreate -- (default is false) used to control whether the resource will be updated for tag webhooks
Optional
cancelPendingRunsOn 

Used to control whether previously triggered runs are canceled for new webhooks

  • newCommit-- (default is false) Cancels previous processing or waiting runs for the same branch for commits, same tag name for tags, and same release name for releases.
  • pullRequestUpdate -- (default is false) Cancels previous processing or waiting runs for the same pull request number when a webhook is received for a pull request.
Optional
shallowDepth Sets the depth at which the repo is (shallow)cloned/fetchedOptional







Environment Variables

Whenever GitRepo is used in a step, a set of environment variables is automatically made available that you can use in your step.

Environment VariableDescription
res_<resource_name>_path
Relative path of the resource
res_<resource_name>_branchName
Name of branch on which the commit occurred. If it was created for a pull request, this is the base branch
res_<resource_name>_commitMessage
Commit message of the version being used
res_<resource_name>_commitSha
SHA of the commit of the version being used
res_<resource_name>_commitUrl
URL to the commit
res_<resource_name>_committerLogin
Name of the committer for the SHA being used
res_<resource_name>_gitProvider_name
Git integration name
res_<resource_name>_gitProvider_url
URL of the Git Provider integration
res_<resource_name>_gitRepoFullName
Name of the Git repo
res_<resource_name>_gitRepoRepositoryHttpsUrl
HTTPS URL for the Git repository
res_<resource_name>_gitRepoRepositorySshUrl
SSH URL for the Git repository.
res_<resource_name>_gitRepoRepositoryUrl
URL for the Git repository
res_<resource_name>_gitRepoSourceDefaultBranch
Default branch of the Git repository
res_<resource_name>_gitTagName
If a tag name was present in the current version, this will be the tag name
res_<resource_name>_integrationName
The name string of the integration used by the GitRepo
res_<resource_name>_isGitTag
True if the version is a git tag based build
res_<resource_name>_isPrerelease
True if the version is a git release based build. Supported only if the integration is GitHub
res_<resource_name>_isPullRequest
True if the version is a git open pull request based build
res_<resource_name>_isPullRequestClose
Trueif the version is a git closed pull request based step. Supported only if the integration is GitHub or Bitbucket or Gitlab.
res_<resource_name>_isRelease
True if the version is a git release based build. Supported only if the integration is GitHub
res_<resource_name>_pullRequestNumber
The ID number of the pull request
res_<resource_name>_pullRequestBaseBranch
Name of the base branch into which the pull request changes will be merged
res_<resource_name>_pullRequestSourceUrl
Source URL of the pull request
res_<resource_name>_resourcePath
Full path of the resource folder on the node 
res_<resource_name>_operation
Input or output resource
res_<resource_name>_shaData

JSON object containing the details of the SHA

res_<resource_name>_beforeCommitSha
SHA before the commit was made
res_<resource_name>_baseCommitRef
The commit SHA of base branch in a PR
res_<resource_name>_compareUrl
Compare URL for the commit
res_<resource_name>_gitTagMessage
If a git tag is created, this holds the message if it is present
res_<resource_name>_releaseName
If a release is created, this holds the name of the release
res_<resource_name>_releaseBody
If a release is created, this holds the description of the release
res_<resource_name>_releasedAt
If a release is created, this holds the date of the release
res_<resource_name>_lastAuthorLogin
Details of when the last author logged in
res_<resource_name>_lastAuthorEmail
Email of the author
res_<resource_name>_committerLogin
Username of the commiter
res_<resource_name>_isBranchCreate
True if a branch was created
res_<resource_name>_isBranchDelete
True if a branch was deleted

Examples

GitRepo resource listening to the master branch
resources:
  - name: my_app_repo
    type: GitRepo
    configuration:
      gitProvider: my_github
      path: myuser/repo-name
      branches:
        include: master
GitRepo resource listening to all branches except master and release
resources:
  - name: my_app_repo
    type: GitRepo
    configuration:
      gitProvider: my_github
      path: myuser/repo-name
      branches:
        exclude: ^(master|release)$


The following example may be useful to reference a single directory in a source repository that contains source code for a single microservice within a larger project.

GitRepo resource listening only to certain files in a directory
resources:
  - name: my_app_repo
    type: GitRepo
    configuration:
      gitProvider: my_github
      path: myuser/repo-name
      branches:
      include: master
      files:
        include: ^folder1\/package\/docker\/micro1\/.+


By default, a GitRepo triggers on a commit, but this can be changed in the buildOn attributes.

GitRepo triggers only for a pull request and not for commit
resources:
  - name: my_app_repo
    type: GitRepo
    configuration:
      gitProvider: my_github
      path: myuser/repo-name
      branches:
        include: master
      buildOn:
        commit: false
        pullRequestCreate: true

For further discussion of triggering, see Triggering Pipelines and Steps.


The following example pipeline triggers the first step on the GitRepo resource.  The step uses the environment variables exposed by the GitRepo resource to navigate to the path where the git repository is cloned on the build node, and to execute a script in that directory.

Usage in a Pipeline
pipelines:
  - name: java_pipeline
    steps:
      - name: step_1
        type: Bash
        configuration:
          inputResources:
            - name: my_app_repo
        execution:
           onExecute:
             - pushd $res_my_app_repo_resourcePath
             - ./execute.sh
             - popd

Further Reading

For more examples on how to use GitRepo and other resources, check out Pipelines Quickstart

  • No labels
Copyright © 2020 JFrog Ltd.